Apprendre Fix — 6. Dériver

Sixième étape, le sommet du parcours. Tout ce que tu as appris converge : un modèle est un type, et on en dérive d'autres artefacts par de simples règles. Compte 15 minutes.

Un modèle, plusieurs cibles

Tes incidents doivent être persistés — décris la table comme des données :

field(incident, service, str).
field(incident, duree, int).

Chaque cible est une transformation — des règles ordinaires :

sql_type(str, varchar).
sql_type(int, integer).
column(E, F, S) :- field(E, F, T), sql_type(T, S).
route(get, E, liste) :- field(E, F, T).

?- column(incident, F, S).
F = service, S = varchar
F = duree,   S = integer

?- route(get, incident, R).
R = liste

Ajoute un champ à field : la colonne et la route suivent — rien ne dérive en silence.

La même règle, dans les deux sens

Comme une règle est une relation, elle se parcourt à l'envers :

?- column(incident, F, integer).
F = duree

« Quels champs deviennent des colonnes entières ? » — la même règle, lue dans l'autre sens. C'est le TDE (Type-Driven Engineering) : le modèle est un type, ses représentations en descendent, et la bidirectionnalité est une propriété de tes types, pas une faveur du moteur.

Et si tu ajoutes une syntaxe de surface (étape 5) de chaque côté, la transformation devient texte à texte : lire (texte → AST), une règle (AST → AST), ecrire (AST → texte). Comprendre déroule l'argument complet, avec l'exemple ER → UML en deux temps.

Verrouille le tout :

test(colonne_duree, holds)   :- column(incident, duree, integer).
test(colonne_service, holds) :- column(incident, service, varchar).
test(route_liste, holds)     :- route(get, incident, liste).

$ fix --test derive.fix
...
1 suite(s) · 3 passé(s) · 0 échoué(s)

Fin du parcours

Tu sais décrire et interroger (étapes 1, 3), fermer et faire calculer les types (étape 2), organiser (étape 4), déclarer une notation (étape 5), et dériver (étape 6) — avec un refus appris à chaque étage : croissance, type, cycle négatif, agrégat non-idempotent. C'est tout Fix : un seul moteur, un seul geste, à tous les étages.

Le REPL sait aussi te documenter lui-même : :help <sujet> (fiche d'un sujet ou d'un code de refus), :demo <sujet> (rejoue un exemple canonique dans un bac à sable, session restaurée à la sortie), et fix --tour (rejoue le parcours, jugé, sans fichier).

Pour continuer :

• Recettes — les réponses ciblées du quotidien.
• Référence — la forme exacte de tout ce qui s'écrit.
• Comprendre — le pourquoi, et le programme TDE complet.