Discussion :

[Jade Emy]

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.

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 - Visualiser dans une fenêtre à part

  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 - Visualiser dans une fenêtre à part

  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 - Visualiser dans une fenêtre à part

  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 - Visualiser dans une fenêtre à part

  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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

$ cargo run -- build

Le compilateur génère des fichiers .go, que vous pouvez exécuter normalement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[abriotde]

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).

[Uther]

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.