Typst est un langage de programmation conçu pour la composition typographique. Un excellent tutoriel est disponible ici ainsi qu’une série d’introduction sur YouTube ici. Pour migrer de \(\LaTeX\) en 2025, j’ai dû passer du temps à explorer le langage pour voir si je pourrais y transférer l’ensemble de mon flux de travail (diapositives, articles, CV, etc.). J’ai rapidement découvert qu’il pouvait faire tout ce que je fais dans \(\LaTeX\) et, surtout, bien plus encore (voir ici). C’est ainsi qu’est née l’idée de cette bibliothèque : c’est une collection de fonctions que j’utilise souvent dans mon enseignement et mes recherches en phonologie.
Dernière mise à jour : February 2026
Un manuel complet de la bibliothèque est disponible en format PDF ici. Le fichier contient de nombreux exemples pour toutes les fonctions de phonokit.
Fonctionnalités principales
Module API
Contrairement à \(\LaTeX\), Typst offre une prise en charge native des caractères Unicode tels que les symboles phonétiques. Bien que ce soit très pratique, j’étais déjà habitué à tipa dans \(\LaTeX\), et mon premier objectif était donc d’avoir une fonction qui émule tipa autant que possible : elle serait familière, pratique et rapide. C’est ce que fait la fonction #ipa(). Il n’existe que des différences mineures entre \textipa{} et #ipa(). Vous pouvez également accéder à une version PDF de la fiche de référence ici.
- Symboles API (
tipa) : utilisez la notationtipafamilière de \(\LaTeX\) plutôt que de chercher des symboles Unicode - Support étendu des symboles : la plupart des consonnes, voyelles et autres symboles de l’API provenant du tableau
tipa - Diacritiques combinantes : nasalisé (
\\~), dévoisé (\\r), syllabique (\\v) ; la ligature (\\t) est également disponible; accent primaire ('), accent secondaire (,), longueur (:) - Découpage automatique des caractères : saisissez
SEau lieu deS Epour plus d’efficacité (l’espacement est nécessaire autour des caractères utilisant des barres obliques inverses) - La police Charis SIL est utilisée pour toutes les transcriptions (https://software.sil.org/charis/download/), mais vous pouvez choisir votre propre police (voir manuel)
Module des tableaux API
J’ai utilisé plusieurs fois la bibliothèque vowel dans \(\LaTeX\), mais son interface ne me convainc pas (voir un exemple dans mon tutoriel \(\LaTeX\) pour phonologues ici). La fonction #vowels() dans phonokit est plus simple : elle prend une chaîne de voyelles et les trace sur un trapèze vocalique. Le trapèze dans Figure 1 a été créé avec #vowels("english"), mais la fonction accepte n’importe quelle chaîne de voyelles, vous pouvez donc personnaliser votre trapèze selon vos besoins. Il en va de même pour la fonction #consonants().
Une fonction similaire existe pour les consonnes : #consonants(). Elle génère un tableau API de consonnes pulmoniques à partir d’un input (chaîne de caractères). Pour #vowels() comme pour #consonants(), vous avez également la possibilité d’utiliser une langue comme input (voir la liste des langues disponibles ci-dessous).
- Trapèzes vocaliques : tracez des voyelles sur le trapèze vocalique de l’API avec un positionnement précis
- Tableaux de consonnes : affichez les consonnes dans le tableau API des consonnes pulmoniques
- Inventaires des langues : inventaires prédéfinis pour certaines langues (anglais, espagnol, français, allemand, italien, portugais, japonais, russe, arabe)
- Jeux de symboles personnalisés : tracez n’importe quelle combinaison de symboles API
- Positionnement automatique : les symboles sont positionnés selon les propriétés phonétiques (lieu, mode, voisement, antériorité, hauteur, arrondissement)
- Mise en forme API correcte : paires sourdes/sonores, articulations impossibles grisées, puces pour les paires minimales de voyelles
- Tableaux redimensionnables : ajustez la taille pour s’adapter à la mise en page de votre document (la mise à l’échelle inclut le texte comme prévu)
À partir de la version 0.4.5, vous pouvez également ajouter des flèches, des voyelles décalées et des surlignages aux trapèzes vocaliques. Cela rend la fonction #vowels() beaucoup plus flexible. Figure 2 montre comment les arguments arrows et highlight peuvent être utilisés pour afficher les diphtongues en anglais nord-américain. Bloc de code 1 montre également comment cous pouvez ajuster indépendamment la couleur des flèches et des surlignages. Enfin, les lignes des flèches peuvent être en pointillés (arrow-style) ou droites (curved: false).
#vowels(
"english",
arrows: (
("a", "U"),
("a", "I"),
("e", "I"),
("O", "I"),
),
arrow-color: blue.lighten(60%),
curved: true,
highlight: ("a", "e", "o", "O"),
highlight-color: blue.lighten(80%),
)
)Module de prosodie
Les fonctions #syllable(), #foot() et #word() vous aident à créer des représentations prosodiques à partir de chaînes de caractères. Elles ajustent automatiquement la taille, mais vous pouvez également utiliser l’argument scale.
- Visualisation de la structure prosodique : tracez des structures syllabiques avec attaque, noyau et coda
- Structure métrique flexible : utilisez des parenthèses pour marquer les frontières explicites du pied et la marque d’accent pour identifier la tête (iambes, trochées)
- Marquage de l’accent : marquez les syllabes accentuées avec une apostrophe
' - Alignement flexible : alignement gauche ou droit pour les têtes de mot prosodique
Figure 3 est le résultat de #foot-mora("'pot.ta", coda: true), où coda: true indique que les codas projettent une more. La fonction détecte les séquences coda-attaque identiques, de sorte que « pot.ta » déclenche la représentation d’une consonne géminée.
Pour créer la représentation des mots prosodiques, la fonction #word() est utilisée. Figure 4 montre un PWd simple généré avec le code #word("('po.Ra).('ma.pa)", foot: "R"), où foot: "R" indique quel pied est le pied principal dans le PWd (lorsque plus d’un pied est présent). Notez que les pieds sont détectés selon l’utilisation des parenthèses dans l’input Les marques d’accent ' sont utilisées pour déterminer la tête du pied. Toutes les fonctions acceptent le même input que la fonction #ipa(), ce qui signifie que les symboles phonétiques sont automatiquement détectés.
Toutes les fonctions impliquant des représentations prosodiques ont également un argument scale. C’est important car nous devons souvent ajuster la taille d’une représentation, mais le texte lui-même peut ne pas s’adapter correctement (la largeur de ligne peut aussi être délicate dans ces scénarios). L’argument en question prend tout en charge.
Module de phonologie autosegmentale
À partir de la version 0.3.0, phonokit propose également une fonction pour créer des représentations autosegmentales, incluant les traits et les tons. L’exemple dans Figure 5 est tiré de Zsiga (2013). Lisez le manuel pour en savoir plus sur la fonction. En résumé, vous pouvez représenter la liaison, la déliaison, les tons flottants et les tons mis en évidence. Ainsi, les processus les plus courants impliquant des traits et des tons sont faciles à représenter avec la fonction #autoseg().
#autoseg(
("e", "b", "e"),
features: ("L", "", "H"),
spacing: 0.5,
tone: true,
gloss: [èbě],
)
#a-r // arrow
#autoseg(
("e", "b", "e"),
features: ("L", "", "H"),
links: ((0, 2),),
spacing: 0.5,
tone: true,
gloss: [_pumpkin_],
)
#autoseg(
("p", "a", "S", "E", "i"),
features: ("", "L", "", "H", "L"),
tone: true,
spacing: 0.5, // keep consistent
delinks: ((1, 1),),
float: (4,),
baseline: 37%,
gloss: [_delinking & floating tone_],
)
#autoseg(
("Z", "W", "p", "K", "u"),
features: ("", "H", "", "", ""), // H at position 1, but will be repositioned
tone: true,
float: (1,), // Mark H as floating so it doesn't draw vertical stem
multilinks: ((1, (1, 4)),), // H links to segments at positions 1 and 4
spacing: 0.5,
baseline: 37%,
arrow: false,
gloss: [_one-to-many relationships_],
)
#autoseg(
("m", "@", "a"),
features: ("", "", ("H", "L")),
links: (((2, 0), 1),), // From H (first tone at position 2) to segment 1
tone: true,
highlight: ((2, 0),), // Highlight the H tone
baseline: 37%,
spacing: 1.0,
arrow: true,
gloss: [_contour tone, linking & highlighting_],
)
#autoseg(
("m", "@", "a"),
features: ("", "", ("H", "L")),
links: (((2, 0), 1),), // From H (first tone at position 2) to segment 1
tone: true,
highlight: ((2, 0),), // Highlight the H tone
baseline: 37%,
spacing: 0.35,
arrow: true,
gloss: [_quick spacing adjustments_],
)Représentations multi-niveaux
Certaines structures phonologiques ont trop de degrés de liberté pour qu’une seule fonction dédiée suffise. C’est pourquoi la fonction #multi-tier() existe (introduite dans la version 0.4.0) : elle vous donne la liberté de créer une large gamme de structures non linéaires. Elle est beaucoup plus flexible, mais cela s’accompagne, par définition, d’une syntaxe plus complexe et de davantage d’arguments. Figure 7, adapté de Booij (2012), illustre un scénario où nous avons besoin de plus de flexibilité dans une fonction pour générer une représentation multi-niveaux.
La fonction #multi-tier() automatise une partie du travail. Premièrement, elle est basée sur une grille avec des coordonnées fixes (mais flexibles). Deuxièmement, la fonction projette des lignes et des liens automatiquement (un par élément ajouté à son argument levels). Les liens restants peuvent être ajoutés avec l’argument links, et les utilisateurs peuvent bien sûr également supprimer les liens automatiques.
L’un des nombreux arguments de #multi-tier() est show-grid, qui imprime une grille pour aider l’utilisateur à localiser les positions des éléments et des liens — ceci est illustré dans Figure 8. Si vous inspectez Bloc de code 4, vous remarquerez que la fonction traite automatiquement les chaînes destinées à être représentées avec des lettres grecques.
#multi-tier(
show-grid: true, // <- To help you see the grid
levels: (
("", "", "", "", ("Adj", 3.5)),
("", "", "", "", ("Adj", 3.5)),
("", ("Af", 0.5), "", ("N", 2.5), "Af"),
("in", "ter", "na", "tion", "al"),
("sigma", "sigma", "sigma", "sigma", "sigma"),
("Sigma", "", "Sigma", "", ""),
("", "", "omega", "", ""),
),
links: (
((0, 4), (2, 1)), // Adj -> Af
((1, 4), (2, 3)), // Adj -> N
((2, 1), (3, 0)), // Af -> in
((2, 3), (3, 2)), // N -> na
((5, 0), (4, 1)), // Ft -> Syl
((5, 2), (4, 3)), // Ft -> Syl
((6, 2), (5, 0)), // PWd -> Ft
((6, 2), (4, 4)), // PWd -> Ft
),
)Enfin, Figure 9, adapté de Goad (2012), montre un autre exemple de la façon dont #multi-tier() peut être utilisé pour générer une large gamme de représentations nécessitant un degré plus élevé de personnalisation. Vous trouverez le code de la figure dans le manuel de l’extension lié en haut de cette page.
Module de grammaire des contraintes
La bibliothèque comprend une fonction pour générer des tableaux OT (voir Figure 10), mais il va plus loin et produit un tableau MaxEnt (Goldwater et Johnson 2003; Hayes et Wilson 2008) avec la fonction #maxent(). Figure 11 illustre un scénario où tous les candidats ont une probabilité non nulle d’être observés pour un input spécifique \(x\). La colonne \(H(y)\) affiche le score d’Harmonie de chaque candidat \(y\), calculé comme la somme pondérée de toutes les violations de contraintes. Ensuite, la colonne \(e^{-H(y)}\) fournit la probabilité non normalisée, qui est l’exponentielle du score d’Harmonie négativé (ceci a également été appelé le score MaxEnt). Enfin, la probabilité prédite réelle est affichée dans la colonne \(P(y|x)\), obtenue en divisant la valeur non normalisée d’un candidat par \(Z(x)\) (la somme de tous les scores non normalisés).
#tableau(
input: "kraTa",
candidates: ("kra.Ta", "ka.Ta", "ka.ra.Ta"),
constraints: ("Max", "Dep", "*Complex"),
violations: (
("", "", "*"),
("*!", "", ""),
("", "*!", ""),
),
winner: 0, // <- Position of winning cand
dashed-lines: (1,), // <- Note the comma
shade: true, // <- true by default
)La fonction #maxent() calcule \(h_i\), \(e^{-h_i}\) et \(P_i\) automatiquement à partir des poids fournis. Figure 11 liste les poids des contraintes utilisées en haut et imprime des barres de probabilité dans la marge de droite. Celles-ci peuvent être désactivées avec visualize: false (voir Bloc de code 6), mais elles sont imprimées par défaut car elles peuvent aider les étudiants à visualiser rapidement les probabilités lorsque de nombreux candidats sont évalués. La fonction peut également trier les candidats par probabilité (sort: true) — voir le tableau en bas de Figure 11.
#maxent(
input: "kraTa",
candidates: ("[kra.Ta]", "[ka.Ta]", "[ka.ra.Ta]"),
constraints: ("Max", "Dep", "*Complex"),
weights: (2.5, 1.8, 1),
violations: (
(0, 0, 1),
(1, 0, 0),
(0, 1, 0),
),
visualize: true, // Show probability bars (default)
// sort: true, // Sort candidates by P
)Il est souvent utile de présenter un classement à l’aide d’un diagramme de Hasse. Ces diagrammes peuvent être générés dans phonokit en utilisant la fonction #hasse(). En résumé, la fonction prend des tuples avec \(n\) éléments. Dans le cas le plus simple, \(n = 1\), ce qui produit une contrainte flottante. L’exemple dans Figure 12 montre un scénario de base. Le troisième élément du premier tuple indique le « niveau » dans le diagramme — ceci est particulièrement important dans les cas plus complexes, qui nécessitent un meilleur contrôle de la position verticale des différentes contraintes. Des arguments optionnels existent pour donner plus de flexibilité à l’utilisateur (par exemple, scale et node-spacing).
#hasse(
(
("*Complex", "Max", 0),
("*Complex", "Dep", 0),
("Onset", "Max", 0),
("Onset", "Dep", 0),
("Max", "NoCoda", 1),
("Dep", "Constraint[Feat]", 1, "dotted"),
),
node-spacing: 3,
)Dépôt de la bibliothèque
Vous pouvez télécharger/bifurquer la version la plus récente de la bibliothèque dans son dépôt GitHub.
Copyright © Guilherme Duarte Garcia