Référence — fiches (commandes, builtins, concepts)

Page générée depuis la base de connaissances (les faits doc_topic/doc du prélude, rendus par :help). C'est la même information que :help <sujet> dans le REPL. Ne l'édite pas à la main — corrige la source (src/prelude.rs) puis régénère (python3 scripts/gen-doc-reference.py).

42 entrées.

Commandes du REPL

assert

:assert Clause. — ajoute et recalcule le point fixe

checkpoint

:checkpoint — compacte la base active (checkpoint écrit, journal tronqué) — mode --db

db

:db — diagnostique la base active : chemin, transactions, tailles, seuils — mode --db

help

:help — la fiche d un sujet ou d un code de refus

listing

:listing — les faits et règles du programme courant

quit

:quit — sortie (quit, halt, exit)

reload

:reload — recharge le fichier source

retract

:retract Fait. — retire et recalcule

save

:save — écrit le programme (faits + règles) dans un .fix rechargeable

Builtins

add

add(X, Y, Z) : X + Y = Z — relationnel, plusieurs sens

agg

agg(Resultat, Operateur, Variable, Source) — min max sum count product avg voir aussi : aggregation

compare

gardes : X > Y, X < Y, X >= Y, X =< Y, X = Y, X != Y voir aussi : arithmetic

div

div(X, Y, Z) : division entière

ecrire

ecrire(Lang, Type, Terme, Texte) : rend Terme (clos, du Type) en texte canonique de Lang — requête top-level uniquement, mode (+,+,+,±) voir aussi : serialisation

lire

lire(Lang, Type, Texte, Terme) : parse Texte (atome quoté) dans Lang vers un terme du Type — requête top-level uniquement, mode (+,+,+,±) voir aussi : serialisation

mod

mod(X, Y, Z) : X modulo Y

mul

mul(X, Y, Z) : X × Y = Z

sub

sub(X, Y, Z) : X − Y = Z

Concepts

aggregation

agg(R, op, V, Source) replie par clé — min/max seuls en récursion à lire avant : basics voir aussi : negation statut : limited(43) refus liés : agg_cyclic, agg_kind_incompat, agg_source_is_head, agg_malformed, agg_op_arity, agg_type_mismatch

arithmetic

builtins relationnels (add/sub/mul/div/mod), gardes, entiers et flottants finis à lire avant : basics refus liés : integer_overflow, float_non_finite

basics

faits, règles, requêtes — décrire ce qui est vrai, le moteur sature (point fixe)

fixdb

mode base durable : fix --db base.fixdb rend la session persistante (append + fdatasync par transaction, réouverture au dernier état acquitté). Le <fichier.fix> n'est ingéré qu'à la CRÉATION d'une base vierge (base existante + source = refus, utilise :load). Commandes : :load ingère un fichier (journalisé), :assert/:retract mutent, :checkpoint compacte (l'auto sur seuil est le défaut), :db diagnostique la base active (chemin, transactions, tailles, seuils), :reload est refusé (la source n'est plus l'autorité). Réparation : --db-repair tronque un journal corrompu au dernier point valide. Sans --db : comportement mémoire à l'identique. à lire avant : run voir aussi : modules refus liés : db_io_error, db_locked, db_version_mismatch, db_corrupted_checkpoint, db_corrupted_journal

hot

règles réifiées en données (rule(Tête, Corps)) + méta-interprète prove — spécifié, pas encore exécutable statut : specified

ilp

generalize (apprendre une règle par l'exemple) — désactivée, au backlog voir aussi : tde statut : disabled refus liés : dual_cyclic, feature_disabled

kinds

ce qu'un type a le droit de faire — inféré, jamais déclaré : le garde-fou invisible à lire avant : types voir aussi : tllp

layout

blocs par indentation (offside) : la mise en page peut porter la structure (sucre := block)

licence

fix enroll — enrôlement de la licence (gatx) ; sans licence valide, le démarrage est refusé

mcp

fix-mcp — Fix comme serveur MCP : outils load/query/assert/retract/… + help, réponses en JSON

modules

espaces de noms à chemins (a::b), exports explicites, encapsulation absolue à lire avant : basics refus liés : empty_qualification, encapsulation_head, nested_module, end_module_without_begin, unclosed_module, module_not_found, not_exported, module_not_imported, selective_import_not_exported, import_ambiguity, cyclic_module_import

negation

not = complément ensembliste typé, stratifié — pas la négation par l'échec à lire avant : types voir aussi : aggregation refus liés : neg_cyclic, neg_unsafe, neg_query_only

parametriques

le paramétrage des types : un type prend des arguments — list(T), pair(A, B) (variables de type en MAJUSCULE ; une minuscule désigne un type nommé). L'argument peut être un type (générique) ou une valeur (dépendant, cf. rdt). Un type est un terme, vérifié par has_type.

query

?- But. — interroge le point fixe ; les variables se lient dans tous les sens (relationnel, aucun mode imposé)

rdt

le type porte une valeur (indice) et la calcule — vec, matrices, unités à lire avant : tllp voir aussi : tde

run

fix <fichier.fix> charge, sature, ouvre le REPL ; --test lance le runner refus liés : file_read_error, file_write_error

safety

toute variable de tête doit être liée par un littéral relationnel du corps à lire avant : basics voir aussi : termination refus liés : var_in_fact, unsafe_rule

serialisation

texte ↔ terme piloté par la syntaxe déclarée (:=, syntax/3) — en requête via lire/ecrire, jamais dans une règle ; :demo serialisation à lire avant : types voir aussi : tde refus liés : lire_ecrire_in_rule, lire_ecrire_not_segmented, lire_ecrire_unknown_language, lire_ecrire_type_undeclared, lire_ecrire_arg_not_ground, lire_ecrire_bad_arity, lire_ecrire_term_not_of_type, lex_error, unexpected_head, premature_end, expected, trailing, malformed_embed, slots_w4, syntax_lang_prefix_obsolete

syntax

identifiants minuscules ASCII ; type/sig/not sont des mots-clés ; multi-ligne au REPL refus liés : unexpected_token, syntax_clause, unexpected_eof, unexpected_char, nesting_too_deep, float_malformed, reserved_underscore, reserved_override

tde

le modèle métier est un type : SQL, DTO, API en descendent par des règles à lire avant : rdt, modules

termination

ce qui compile termine : la garde refuse les règles croissantes — réécris en descente à lire avant : arithmetic voir aussi : safety refus liés : rule_growing, eval_not_converged, eval_work_budget, eval_strata_unsatisfiable, eval_decreasing_agg_cycle

tllp

has_type est un prédicat ordinaire : des types affinés définis par des règles à lire avant : types

types

type ferme un jeu de valeurs, sig déclare les positions — l'écart est fatal à la compilation à lire avant : basics refus liés : type_error, type_error_fact, type_error_value_not_in_type, type_error_value_not_in_type_nested, type_error_number_not_allowed, type_error_label_not_allowed, type_error_structure_not_allowed, type_error_wrong_arity, type_error_no_signature, type_error_mixed_shapes, type_error_rule, type_error_no_sig, type_error_depth, type_error_multisort, type_error_subtype_open_source, unknown_kind, any_type_banned, type_error_cell, redeclaration, duplicate_decl, subtype_nonground, reserved_kind_name, reserved_pred_name, type_binder_lowercase, type_var_free_in_variant

unification

l'unification lie les variables en filtrant deux termes — premier ordre, avec occurs-check