Zig (langage)

Zig
Date de première version	2015
Paradigme	Fonctionnel, impératif
Auteur	Andrew Kelley
Développeur	Andrew Kelley, Open Source
Dernière version	0.12.0 (20/04/2024)
Typage	Fort, statique
Influencé par	C, C++, LLVM IR, Go, Rust, JavaScript
Écrit en	C++, Zig
Systèmes d'exploitation	Multiplateforme
Licence	Licence MIT
Site web	https://ziglang.org/
Extensions de fichiers	.zig

Zig est un langage de programmation compilé impératif polyvalent, typé statiquement, conçu par Andrew Kelley. Le langage est conçu pour la «robustesse», l'«optimalité» et la «maintenabilité», prenant en charge les génériques et la réflexion au moment de la compilation, la compilation croisée et l'allocation de mémoire manuelle (cad. sans ramasse-miette). Un objectif majeur du langage est de concurrencer (et d'améliorer) C, tout en s'inspirant également de Rust, entre autres.

Zig possède de nombreuses fonctionnalités pour la programmation de bas niveau, notamment des types composés (struct) avec zéro padding, des entiers de taille arbitraire et différents types de pointeurs.

Le compilateur, originellement écrit en C++, a lentement été réécrit en Zig pour être aujourd'hui disponible dans sa version entièrement implémentée en Zig, nommée Stage 2. Il utilise LLVM 11 comme back-end , prenant en charge plusieurs de ses cibles natives, bien que d'autres back-ends soient en développement. Le compilateur est un logiciel libre et open source distribué sous la licence MIT. Le compilateur Zig fournit la possibilité de compiler du C et du C++, similaire à Clang en utilisant respectivement la commande "zig cc" et "zig c++". Le langage de programmation Nim prend en charge l'utilisation de zig cc comme compilateur C.

Exemples

Hello World

// zig version 0.7.1
const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {}!\n", .{"world"});
}

QuickSort avec choix de la fonction de comparaison

const std = @import("std");

pub fn quickSort(comptime T: type, arr: []T, comptime compareFn: fn (T, T) bool) void {
    if (arr.len < 2) return;

    const pivot_index = partition(T, arr, compareFn);
    quickSort(T, arr[0..pivot_index], compareFn);
    quickSort(T, arr[pivot_index + 1 .. arr.len], compareFn);
}

fn partition(comptime T: type, arr: []T, comptime compareFn: fn (T, T) bool) usize {
    const pivot_index = arr.len / 2;
    const last_index = arr.len - 1;

    std.mem.swap(T, &arr[pivot_index], &arr[last_index]);

    var store_index: usize = 0;
    for (arr[0 .. arr.len - 1]) |*elem_ptr| {
        if (compareFn(elem_ptr.*, arr[last_index])) {
            std.mem.swap(T, elem_ptr, &arr[store_index]);
            store_index += 1;
        }
    }

    std.mem.swap(T, &arr[store_index], &arr[last_index]);
    return store_index;
}

pub fn main() void {
    const print = std.debug.print;

    var arr = [_]i16{ 4, 65, 2, -31, 0, 99, 2, 83, 782, 1 };
    print("Before: {any}\n\n", .{arr});

    print("Sort numbers in ascending order.\n", .{});
    quickSort(i16, &arr, struct {
        fn sortFn(left: i16, right: i16) bool {
            return left < right;
        }
    }.sortFn);
    print("After: {any}\n\n", .{arr});

    print("Sort numbers in descending order.\n", .{});
    quickSort(i16, &arr, struct {
        fn sortFn(left: i16, right: i16) bool {
            return left > right;
        }
    }.sortFn);
    print("After: {any}\n\n", .{arr});
}

Philosophie

Le "Zen" de Zig, qui peut être lu sur le site de la fondation Zig, est un ensemble d'idées sur ce qui est important dans le langage Zig. Dans leurs mots :

• Communiquer les intentions précisément
• Les cas spéciaux ou rares sont importants
• Favoriser la lecture du code par dessus l'écriture
• Une seule manière d'écrire les choses
• Les crash à l'exécution sont meilleurs que les bugs
• Les erreurs à la compilation sont meilleures que les crashs
• Améliorations incrémentales
• Éviter les maxima locaux
• Réduire ce qu'on doit retenir
• Se concentrer sur le code plutôt que sur le style
• L'allocation de ressources peut échouer, la libération doit réussir
• La mémoire est une ressource
• Ensemble nous servons l'utilisateur

Bien que la Fondation Zig existe, avec son site web, et un compilateur (le seul à ce jour), la communauté Zig n'a pas de concept d'officiel ou non-officiel, et tout le monde est libre de créer son site, sa communauté, ses outils Zig, voire un compilateur, qui ne sera pas plus officiel que ceux déjà existants.

Voir également

Articles connexes

• C
• C++
• Nim
• Rust
• D

Liens externes

• Site officiel
• Zig sur GitHub
• Film: Présentation de Zig
• Film: La route vers 1.0