Des programmes d’accord sur les types
Un composant WebAssembly est un module accompagné d’une description typée de ce qu’il importe et exporte. Cette description s’écrit en WIT, le WebAssembly Interface Type. Grâce à elle, un composant écrit en Rust peut passer une chaîne ou une liste à un composant écrit en Python.
Aujourd’hui, vous lisez un fichier WIT et vous appelez un composant à travers lui.
À la fin de cette leçon
Remarque
Je peux lire un monde WIT et dire ce qu’un composant importe et exporte.
Mots-clés
| Mot | Ce que ça veut dire | Exemple |
|---|---|---|
| Composant | un module avec des imports et des exports typés | |
| WIT | le langage qui décrit ces types | calc.wit |
| Interface | un groupe nommé de fonctions et de types | math |
| Monde | tout ce qu’un composant importe et exporte | world doubler |
| Package | le nom et la version d’un ensemble d’interfaces | demo:[email protected] |
| Lift | transformer une fonction de base en fonction typée |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Un module de base ne parle qu’en nombres
Un module simple, dit module de base, passe quatre sortes de valeurs : i32, i64, f32 et f64. Une chaîne doit voyager comme une adresse en mémoire et une longueur, et les deux côtés doivent s’accorder sur la manière.
Le Component Model fixe cet accord une fois pour toutes, dans l’ABI canonique. WIT dit string, list ou record, et le runtime déplace les octets. Deux composants ne partagent jamais leur mémoire.
Lire le fichier WIT du labo
docker exec tools cat calc.witAffichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.
Exemple travaillé : les parties de calc.wit
| Ligne | Genre | Ce qu’elle dit |
|---|---|---|
| package demo:[email protected]; | package | Espace de noms demo, nom calc, version 0.1.0 |
| interface math { ... } | interface | Une fonction, add: func(a: u32, b: u32) -> u32 |
| world calculator { export math; } | monde | Un composant qui fournit math |
| world doubler { import math; export double: ... } | monde | A besoin de math, fournit double |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Un composant est un module avec ses types
Ouvrez calc.wat avec docker exec tools cat calc.wat. On y trouve un module de base ordinaire, dont la fonction add prend deux i32 et en renvoie un.
Une ligne canon lift en fait add: func(a: u32, b: u32) -> u32, le type promis par WIT. Le composant l’exporte dans l’instance demo:calc/[email protected]. Wasmtime peut l’appeler par son nom avec --invoke.
Appeler la fonction add du composant
docker exec wasm wasmtime run --invoke 'add(2, 3)' calc.watAffichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.
Additionner deux nombres trop grands
docker exec wasm wasmtime run --invoke 'add(4000000000, 500000000)' calc.watAffichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.
Un monde est un contrat avec l’hôte
Un monde liste ce dont un composant a besoin et ce qu’il fournit. L’hôte doit fournir chaque import avant que le composant démarre. Le monde est donc tout ce que le composant peut toucher.
WASI s’écrit lui aussi en mondes WIT. Un composant en ligne de commande importe des interfaces comme wasi:filesystem et wasi:cli/environment, et exporte wasi:cli/run. Un hôte peut lire cette liste avant de lancer quoi que ce soit.
Erreur fréquente
Attention
On croit souvent qu’un fichier WIT est du code qui s’exécute. WIT décrit seulement des types et des fonctions, comme un contrat. Le code est dans le composant, et le même WIT peut être respecté par des composants écrits dans n’importe quel langage.
À vous : pourquoi 4,5 milliards donnent 205032704
MODULO = 2 ** 32
def addition_u32(a, b):
# Un i32.add de base ne garde que les 32 bits bas de la somme.
return (a + b) % MODULO
def en_signe(n):
# Les mêmes 32 bits, lus comme un nombre signé.
if n >= 2 ** 31:
return n - MODULO
return n
for paire in [[2, 3], [4000000000, 500000000], [3000000000, 0]]:
somme = addition_u32(paire[0], paire[1])
print(paire[0], "+", paire[1], "=", somme, "en u32 et", en_signe(somme), "en s32")
# Ajoutez [4294967295, 1] à la liste. Sur quoi la somme se replie-t-elle ?