Introduction à Hare

Article écrit par Willow 

Présentation du langage Hare

Pour celles et ceux qui ne le savent pas déjà, je suis admiratrice de Drew Devault, un développeur qui est à l’origine d’un grand nombre d’outils que j’utilise, par exemple Sway, Aerc ou SourceHut.

Si je vous parle de lui, c’est qu’il a annoncé l’an passé qu’il travaillait sur un nouveau langage de programmation. Comme je tombe souvent d’accord avec les paradigmes et designs applicatifs qu’il promeut, je me suis intéressée à ce langage lorsqu’il a donné plus d’information.

Je souhaite donc présenter les spécificités de Hare, et pourquoi ça deviendra probablement mon langage de prédilection à terme.

Pour commencer voici un extrait de code générique pour vous donner un aperçu de sa grammaire :

use bufio;
use fmt;
use os;
use strings;

export fn main() void = {
	const user = askname();
	defer free(user);
	greet(user);
};

// Asks the user to provide their name.
fn askname() str = {
	fmt::println("Hello! Please enter your name:")!;
	const name = bufio::scanline(os::stdin)! as []u8;
	return strings::fromutf8(name)!;
};

// Greets a user by name.
fn greet(user: str) void = {
	fmt::printfln("Hello, {}!", user)!;
};

La première chose notable est que le langage est statiquement typé. Il se veut le plus déclaratif possible, mais son typage offre cependant bien des surprises.

Ici const user = askname(); on remarque que le type str provient de la déclaration de la méthode askname() elle-même. Par contre, vous avez peut-être bloqué sur const name = bufio::scanline(os::stdin)! as []u8;. Qu’est-ce que ce ! et qu’est-ce que as []u8 ? Jetons un coup d’œil à la documentation :

$ haredoc bufio::scanline
// Reads a slice of bytes until a newline character (\n, 0x0A). Newline itself
// is not included. The return value must be freed by the caller.
fn scanline(
        file: io::handle,
) ([]u8 | io::EOF | io::error);

La méthode scanline() renvoie une union de type. Ici on aura soit un []u8 qui est un slice d’entier non signé sur 8 bits (tableau dynamique de caractères), soit un io::EOF qui est un type custom au module io, soit un io:error qui est aussi un type custom, mais qui est défini comme représentant une erreur. La doc suivante montre la définition de ce type.

$ haredoc io::error
// Any error which may be returned from an I/O function.
type error = !(...errors::error | underread);
$ haredoc errors::error
// A tagged union of all error types.
type error = !(busy | exists | invalid | noaccess |
        noentry | overflow | unsupported | timeout |
        cancelled | refused | nomem | interrupted |
        again | opaque);

On y lit un ! qui indique que c’est un type d’erreur. On remarque également que io::error est lui-même une union de plusieurs erreurs communes.

Le fait d’écrire as []u8 est un moyen rapide d’indiquer qu’on est confiant sur le fait que l’usage actuel va renvoyer un []u8. Le programme échouera à l’exécution dans le cas contraire.

Le ! quant à lui indique que le code ne traitera pas des erreurs de retours. Le programme échouera donc si cela se produit.

Cet usage du ! et du as est le moyen rapide de récupérer votre chaine de caractères lorsque vous êtes sûr que tout ira bien dans l’usage actuel. Ce n’est généralement pas le cas ! La meilleure approche du langage est match :

const name = match(bufio::scanline(os::stdin)) {
	case let n: []u8 =>
		yield n;
	case io::EOF =>
		fmt::fatal("We fetched the end of the input");
	case io::error =>
		fmt::fatal("Something went wrong");
	};;

Après ces quelques lignes, name sera un []u8 ou le programme aura échoué.

Si je puis résumer la logique ainsi : Ici et maintenant, tu traites tous les cas possibles, ou tu crash. Mais on ne va pas crasher à l’autre bout de l’application parce que quelque part, quelque chose s’est mal passé.

Grâce à son design, Hare oblige ses développeurs à traiter tous les cas de retour possible. Vous serez forcé par le compilateur à fournir un case pour tous les types de retours. Je ne rentre pas dans les détails, mais il existe des moyens pour propager et traiter efficacement les erreurs. Hare va au bout de son concept et ordonne une rigueur tout en restant facile à coder et à lire.

J’ai présenté Hare sous l’angle de son typage et de sa gestion des erreurs car c’est selon moi sa particularité et sa force. Si vous souhaitez approfondir votre découverte, rendez-vous sur le site de Hare.