Langage Carbon

J'ai lu un peu la doc du langage ici. Voici un exemple de code :

package Sorting api;
fn Partition[T:! Comparable & Movable](s: Slice(T))
 -> i64 {
 var i: i64 = -1;
 for (e: T in s) {
 if (e <= s.Last()) {
 ++i;
 Swap(&s[i], &e);
 }
 }
 return i;
}
fn QuickSort[T:! Comparable & Movable](s: Slice(T)) {
 if (s.Size() <= 1) {
 return;
 }
 let p: i64 = Partition(s);
 QuickSort(s[:p - 1]);
 QuickSort(s[p + 1:]);
}

Au niveau des différence que j'ai trouvé :
- les littéraux numériques ne sont pas en octal, et ils peuvent être de taille 128 bit et 256 bit.
- il y a un type String et un type StringView avec un StringView en lecture seule
- il existe le type tuple, un type slice
- il y a un opérateur move pour déplacer une valeur. Dans l'instruction :

x = ~y; 

apres cette instruction, y est dans un état indéfini.
- il y a une instruction return var. L'idée c'est de déclarer une variable comme type de retour, et quand on appel return var, ça va retourner cette valeur.

fn MakeCircle(radius: i32) -> Circle {
 returned var c: Circle;
 c.radius = radius;
 // `return c` would be invalid because `returned` is in use.
 return var;
}

• il y a une instruction match qui a l'air pas mal par rapport aux tuples

fn Bar() -> (i32, (f32, f32));
fn Foo() -> f32 {
 match (Bar()) {
 case (42, (x: f32, y: f32)) => {
 return x - y;
 }
 case (p: i32, (x: f32, _: f32)) if (p < 13) => {
 return p * x;
 }
 case (p: i32, _: auto) if (p > 3) => {
 return p * Pi;
 }
 default => {
 return Pi;
 }
 }
}

• il n'y a pas de GC
• le langage peut créer des objets du C++ et les manipuler
• il n'y a pas de préprocesseur à la C. Il y aura un système de métaprogramming, mais il n'est pas documenté.
• on peut créer des classes, et l’héritage est simple. la création d'un objet est simple :

var sprocket: Widget = {.x = 3, .y = 4, .payload = "Sproing"};

• Les classes ont des destructeurs
• il existe un type choix :

choice IntResult {
 Success(value: i32),
 Failure(error: String),
 Cancelled
}

• il y a un système de package, un mécanisme d'importation, et un mécanisme de namespace
• il y a des génériques qui peuvent être déclaré au niveau d'une méthode ou d'une classe
• il y a des interfaces
• il y a la surcharge d'opérateur
• il n'y a pas d'exception

Le langage n'est pas fini, et il y a des parties qui sont en cours de conception.