IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Présentation de Borgo : un langage de programmation statiquement typé qui se compile en Go
Combinant la simplicité de Go et la sécurité de Rust

Le , par Jade Emy

27PARTAGES

8  0 
Voici la présentation du langage de programmation Borgo, un langage qui se veut simple comme Go, mais avec la sécurité de Rust.

Je veux un langage pour écrire des applications qui soit plus expressif que Go, mais moins complexe que Rust.

Go est simple et direct, mais je regrette souvent qu'il n'offre pas plus de sécurité de type. Rust est très agréable à utiliser (au moins pour le code à un seul thread) mais il est trop large et complexe, parfois douloureusement.

Borgo est un nouveau langage qui se transpose à Go. Il est entièrement compatible avec les paquets Go existants.

La syntaxe de Borgo est similaire à celle de Rust, avec des points-virgules optionnels.


Fonctionnalités

  • Types de données algébriques et filtrage

    Code : Sélectionner tout
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    use fmt
     
    enum NetworkState {
        Loading,
        Failed(int),
        Success(string),
    }
     
    let msg = match state {
        NetworkState.Loading => "still loading",
        NetworkState.Failed(code) => fmt.Sprintf("Got error code: %d", code),
        NetworkState.Success(res) => res,
    }

  • Option<T> au lieu de nil

    Code : Sélectionner tout
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // import packages from Go stdlib
    use fmt
    use os
     
    let key = os.LookupEnv("HOME")
     
    match key {
        Some(s) => fmt.Println("home dir:", s),
        None => fmt.Println("Not found in env"),
    }

  • Result<T, E> au lieu de plusieurs valeurs de retour

    Code : Sélectionner tout
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    use fmt
    use net.http
     
    fn makeRequest() -> Result<int, error> {
        let request = http.Get("http://example.com")
     
        match request {
            Ok(resp) => Ok(resp.StatusCode),
            Err(err) => Err(fmt.Errorf("failed http request %w", err))
        }
    }

  • Gestion des erreurs avec l'opérateur ?

    Code : Sélectionner tout
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    use fmt
    use io
    use os
     
    fn copyFile(src: string, dst: string) -> Result<(), error> {
        let stat = os.Stat(src)?
     
        if !stat.Mode().IsRegular() {
            return Err(fmt.Errorf("%s is not a regular file", src))
        }
     
        let source = os.Open(src)?
        defer source.Close()
     
        let destination = os.Create(dst)?
        defer destination.Close()
     
        // ignore number of bytes copied
        let _ = io.Copy(destination, source)?
     
        Ok(())
    }


Exemple

Petit jeu tiré du livre Rust, implémenté en Borgo.

Ce qu'il faut noter :

  • importation de paquets de Go stdlib
  • strconv.Atoi renvoie une Option<int>
  • Reader.ReadString renvoie un Result<string, error> (qui peut être déballé)


Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
use bufio
use fmt
use math.rand
use os
use strconv
use strings
use time
 
fn main() {
    let reader = bufio.NewReader(os.Stdin)
 
    rand.Seed(time.Now().UnixNano())
    let secret = rand.Intn(100) + 1
 
    loop {
        fmt.Println("Please input your guess.")
 
        let text = reader.ReadString('\n').Unwrap()
        let text = strings.TrimSpace(text)
 
        let guess = match strconv.Atoi(text) {
            Ok(n) => n,
            Err(_) => continue,
        }
 
        fmt.Println("You guessed: ", guess)
 
        if guess < secret {
            fmt.Println("Too small!")
        } else if guess > secret {
            fmt.Println("Too big!")
        } else {
            fmt.Println("Correct!")
            break
        }
    }
}


Exécution locale

Borgo est écrit en Rust, vous aurez donc besoin de cargo.

Pour compiler tous les fichiers .brg dans le dossier courant :

Code : Sélectionner tout
$ cargo run -- build
Le compilateur génère des fichiers .go, que vous pouvez exécuter normalement :

Code : Sélectionner tout
1
2
3
# generate a go.mod file if needed
# $ go mod init foo
$ go run .
Source : Présentation de Borgo

Et vous ?

Quel est votre avis sur Borgo ?

Voir aussi :

Enquête sur le langage Go: les devs sont intéressés par les outils IA/ML qui améliorent la qualité, la fiabilité et les performances de leur code. Ils sont sur Linux et macOS pour la plupart

Sortie de la version 1.22 du langage Go, apportant des changements à l'implémentation de la chaîne d'outils, au moteur d'exécution et aux bibliothèques

La version 1.76.0 de Rust, le langage de programmation compilé multi-paradigme, est disponible, et apporte une nouvelle documentation sur la compatibilité ABI, ainsi que d'autres améliorations

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de abriotde
Membre chevronné https://www.developpez.com
Le 07/05/2024 à 20:58
C'est la syntaxe Rust un poil simplifier mais la performance de Go... : les inconvénients de Rust sans les avantages? Sans compter qu'il y a une étape de transpilation en plus.

L'intérêt que j'y vois c'est pour une transition en douceur de Go à Rust ou, inversement, utiliser Go pour un programmeur Rust en gardant ses réflexe Rust (Pour plus de rapidité de production ou pour la simplicité des exe Go ou pour ses librairies).
2  0 
Avatar de Uther
Expert éminent sénior https://www.developpez.com
Le 08/05/2024 à 7:31
Il faut reconnaitre que l'on gagne quand même certaine fonctionnalités de la syntaxe Rust (comme les enum avancés et la gestion d'erreur qui font cruellement défaut à Go) sans la complexité de la gestion de mémoire vérifiée par le compilateur. Cela dit, même si je reconnais que l'idée est intéressante, c'est juste un petit projet sans prétention qui n'aura probablement pas un gros avenir.

Je suis assez d'accord que ce compromis qui a peu de chance de séduire grand monde à part les habitués de Rust qui ont besoin de faire rapidement un programme sans prétention niveau performance, ce qui représente une niche dans une niche.
1  0