Fonctionnalités du langage
Tout ce qu'il vous faut pour construire des services résilients et performants.
Modèle d'acteurs
Les acteurs sont l'unité fondamentale de calcul dans Hew. Chaque acteur possède son état de façon exclusive, avec des tas mémoire isolés et un passage de messages typé. Le compilateur vérifie que tous les messages sont Send-compatibles à la compilation.
- ▸ Isolation sans coût
- ▸ Vérification Send à la compilation
- ▸ Exécution mono-fil par acteur
- ▸ Boîtes aux lettres bornées avec contre-pression
- ▸ Appels de méthode directs :
counter.increment(10) - ▸ Acteurs lambda avec l'opérateur d'envoi
<-:worker <- 42
Modèle mémoire
Hew utilise RAII — la mémoire est récupérée de façon déterministe via le trait Drop à la sortie de portée. Chaque acteur possède son propre tas, et lorsqu'un acteur se termine, l'ensemble de son tas est libéré en une seule opération. Les messages entre acteurs utilisent la sémantique copy-on-send : les valeurs sont copiées en profondeur, maintenant la mémoire de chaque acteur pleinement isolée.
- ▸ Basé sur RAII avec récupération déterministe
- ▸ Destruction déterministe via le trait Drop
- ▸ Propriété du tas par acteur
- ▸ Copie à l'envoi pour les messages inter-acteurs
Arbres de supervision
Inspiré d'Erlang/OTP, Hew fait de la tolérance aux pannes une fonctionnalité du langage. Les superviseurs relancent automatiquement les acteurs défaillants avec des stratégies configurables et des budgets de redémarrage.
- ▸ Stratégies one_for_one, one_for_all, rest_for_one
- ▸ Les budgets de redémarrage confinent les défaillances
- ▸ Les hiérarchies de supervision se composent
- ▸ Sémantique d'escalade pour les défaillances irrécupérables
Concurrence structurée
Les tâches dans Hew sont toujours délimitées. Un Task<T> représente un travail concurrent au sein d'un acteur. Lancez des tâches avec s.launch dans un bloc scope |s| { ... } — lorsqu'une portée parente se termine, elle attend que toutes les tâches enfants soient complètes avant de continuer. Chaque tâche a un propriétaire, et chaque propriétaire nettoie. L'annulation explicite est disponible via s.cancel().
- ▸
Task<T>— calcul concurrent typé - ▸
s.launchdansscope |s| { ... }pour des tâches à durée de vie bornée - ▸ Ordonnanceur M:N avec vol de travail sur plusieurs cœurs CPU
- ▸ Annulation coopérative via
s.cancel() - ▸ Jointure automatique — la portée attend tous les enfants
Patrons de concurrence
Hew fournit des constructions de langage de première classe pour les patrons de concurrence courants. select attend la première de plusieurs opérations et join exécute des tâches en parallèle et collecte tous les résultats. select prend en charge les délais after pour les alternatives basées sur des délais.
- ▸
select {}— attendre la première branche prête - ▸
join {}— tout exécuter, tout collecter - ▸ Clauses de délai
aftersurselect
Machines à états
La plupart des acteurs à longue durée de vie sont des machines à états dans leur essence. Hew rend cela explicite avec machine, state, event, et on comme constructions du langage. Le compilateur valide les transitions, vérifie les expressions de garde, et contrôle l'accessibilité des états à la compilation.
- ▸ Déclarations
machinedans les acteurs - ▸ États nommés avec événements typés
- ▸ Gardes
whenréférençant les champs de l'acteur - ▸ Vérification d'exhaustivité à la compilation
Acteurs distribués
Démarrez des acteurs sur des nœuds distants avec spawn ... on node. Le compilateur garantit que tous les arguments et messages sont compatibles avec le réseau. Les références à des acteurs distants sont identiques aux locales — les envois de messages sont sérialisés et acheminés via TCP de façon transparente.
- ▸
spawn Actor(args) on node - ▸ Références locales/distantes transparentes
- ▸ Appartenance au cluster basée sur le gossip
- ▸ Sécurité réseau à la compilation pour tous les messages distants
Contrats réseau
Les protocoles réseau sont des types de première classe dans Hew. Les types réseau définissent le format de sérialisation, la numérotation des champs, et les règles d'évolution de schéma. Le compilateur applique une évolution compatible vers l'avant — les nouveaux champs s'intègrent sans risque aux déploiements existants.
- ▸ Format binaire Hew (HBF) — encodage binaire compact
- ▸ Encodage JSON pour l'interopérabilité externe
- ▸ Évolution de schéma avec des étiquettes de champ
- ▸ Vérifications de compatibilité à la compilation
Système de types
Le système de types de Hew garantit l'isolation des acteurs à la compilation. Les types portent des traits de capacité Send + Frozen pour la sécurité inter-acteurs, tandis qu'au sein d'un acteur vous avez pleine liberté de mutation. L'inférence de types bidirectionnelle minimise les annotations et les génériques sont monomorphisés pour une abstraction sans coût.
Génériques avec monomorphisation
Types et fonctions génériques sans coût. Le compilateur génère du code spécialisé pour chaque type concret — complètement inline, complètement optimisé.
Traits de capacité Send + Frozen
Les types portent des capacités que le compilateur applique. Send pour le transfert inter-acteurs, Frozen pour l'accès immuable partagé. Au sein d'un acteur, vous avez pleine liberté de mutation — le compilateur vérifie les frontières, là où ça compte.
Inférence de types bidirectionnelle
Les types circulent des contextes d'appel vers les lambdas et les génériques. Le compilateur déduit les types des paramètres à partir des signatures — annotations minimales, sécurité totale à la compilation.
Correspondance de motifs avec exhaustivité
Les expressions match sont vérifiées pour leur complétude à la compilation. Le compilateur s'assure que chaque cas possible est traité.
FFI C avec des blocs extern
Appelez directement des bibliothèques C. Les blocs extern déclarent des fonctions externes avec une sécurité de types totale à la frontière.
Option<T> et Result<T, E>
Les valeurs optionnelles et la gestion des erreurs sont explicites dans le système de types. Chaque absence est typée, chaque défaillance est prise en charge.
Trait Iterator avec adaptateurs
Composez des transformations paresseuses sur des séquences. Map, filter, fold — fusionnés en boucles efficaces par le compilateur.
Compilation
Hew compile en code machine natif. La commande hew build pilote un frontend Rust et un backend C++ MLIR, en utilisant un abaissement progressif via LLVM.