Tagged 2026-05-27. 3 commits depuis v0.6.0. La release où les trois phases se rencontrent : récursion native (Phase A) + types sommes (Phase B) + preuves de terminaison (Phase C) composent dans un seul binaire qui tokenize du texte.

Shipped

token_scan — premier scanner Token concept_group (PR #57, 2260 octets)

  • What — quatre règles composées dans un binaire natif qui prend du texte brut et produit des tokens typés. Word, Num, Eof sont des variantes d’un concept_group Token. Le scanner avance dans le texte byte par byte via récursion (increasing : pos), reconnaît les lettres (mots) et les chiffres (nombres), et retourne le variant correspondant.
  • Why — c’est le premier programme verbose qui combine les trois phases : récursion native (Phase A) pour le scanning, types sommes (Phase B) pour les variantes Token, preuve de terminaison (Phase C) pour garantir la convergence. Avant cette PR, chaque phase fonctionnait isolément. Ici, elles s’assemblent.
  • Choice — un seul ELF de 2260 octets. Pas de runtime, pas d’allocateur dynamique. Les tokens sont construits dans l’arène (Phase B slice 4a), retournés via le match dispatch natif.

count_tokens — boucle tokenizer complète (PR #58, 1691 octets)

  • What — trois callables composés qui traitent un flux de tokens complet. skip_spaces avance au-delà des espaces, word_length compte les lettres consécutives, et la boucle principale itère sur le texte entier en produisant un compte de tokens.
  • Why — token_scan scanne UN token. count_tokens boucle sur TOUS les tokens. C’est le pattern du tokenizer complet — le même qui sera nécessaire pour l’auto-hébergement (un compilateur verbose qui lit du source verbose).
  • Choice — composition via let bindings (PR #54). Chaque callable a sa propre preuve de terminaison (increasing : pos). Le frame empile les résultats intermédiaires. 1691 octets pour un tokenizer multi-tokens — plus petit que le scanner mono-token parce que les callables partagent le code commun.

What we learned

Les phases composent. C’est le résultat le plus important de cette release. Phase A donnait la récursion. Phase B donnait les types. Phase C donnait les preuves. Séparément, chaque phase est un progrès technique. Ensemble, elles produisent un tokenizer natif prouvé terminant en 2260 octets. C’est la thèse de verbose qui se matérialise : le développeur déclare, le compilateur vérifie, le binaire est minimal et sûr.

Open

  • Tokenizer verbose complet (identifieurs, opérateurs, mots-clés) — prochaine étape vers l’auto-hébergement
  • Phase C : preuves multi-field
  • Phase D (self-hosting) : estimé 6-12 mois

How to try

git clone https://github.com/verbose-org/verbose
cd verbose
cargo run -- examples/count_tokens.verbose --native /tmp/count_tokens --run count_tokens --stream
echo "hello world 42" | /tmp/count_tokens