Le langage en aperçu

Un tour d'horizon des fonctionnalités d'Amalgame, en code commenté.

Hello, world

Le squelette d'un programme : un namespace, une classe, un point d'entrée. La syntaxe est familière (style C#/Kotlin), accessible immédiatement.

namespace App
import Amalgame.IO

public class Program {
    public static void Main(string[] args) {
        Console.WriteLine("Hello, Amalgame!")
    }
}

Variables, types, null-safety

let pour les valeurs immuables, var pour les mutables. Inférence de type ou annotation explicite. Le suffixe ? rend un type nullable, et ?. permet l'accès safe.

let name: string = "Amalgame"
var count = 0
count = count + 1

// Null-safety
let maybe: Greeter? = null
let label = maybe?.Hello()  // label est null si maybe est null

Pattern matching

Le match est une expression. Il supporte les guards, les ranges, les binders, et les enums algébriques avec destructuring.

let n = 42
let bucket = match n {
    0           => "zero"
    x if x < 0  => "negative"
    1..9        => "small"
    10..99      => "medium"
    _           => "large"
}

public enum Shape {
    Circle(int)
    Rect(int, int)
}

match shape {
    Circle(r)  => Console.WriteLine("r={r}")
    Rect(w, h) => Console.WriteLine("rect")
}

Lambdas et list comprehensions

Lambdas multi-paramètres, capture de scope, méthodes higher-order sur les listes.

// List comprehension
let squares = [i * i for i in 0..10 if i % 2 == 0]

// Higher-order
let total = numbers.Filter(n => n > 0)
                  .Map(n => n * 2)
                  .Reduce(0, (acc, n) => acc + n)

// Pipeline operator
let shouted = name |> String.ToUpper |> String.Trim

Generics et interfaces

Génériques effacés à void* au niveau C, mais avec vérification statique côté compilateur. Les interfaces génériques imposent des contrats vérifiés à la compilation.

public class Box<T> implements IComparable<int> {
    public Value: T

    public int CompareTo(int other) {
        return 0
    }
}

Tuples et destructuring

public static (int, int) DivMod(int a, int b) {
    return (a / b, a % b)
}

let (q, r) = Program.DivMod(17, 5)
Console.WriteLine("{q} rem {r}")  // String interpolation

Et la suite

Pour aller plus loin : le guide complet sur GitHub, ou directement installer Amalgame.