Catalogue des erreurs

Page générée depuis la base de connaissances : les faits error_template/3 du prélude (le message), routés par doc_error/2 (le sujet). Ne l'édite pas à la main — corrige la source (src/prelude.rs) puis régénère (python3 scripts/gen-doc-erreurs.py). Chaque {} est un trou rempli à l'exécution par les arguments du refus.

87 codes · 13 sujets.

aggregation

`agg_cyclic`

agrégat non-idempotent dans un cycle : {}

`agg_kind_incompat`

agrégat {} : mode {} incompatible (requiert {})

`agg_malformed`

agrégat mal formé : {}

`agg_op_arity`

opérateur d'agrégat {} mal typé (arité {})

`agg_source_is_head`

agrégat : tête et source identiques ({})

`agg_type_mismatch`

agrégat {} : type incompatible, attendu {}, reçu {}

arithmetic

`float_non_finite`

flottant non fini (NaN/Inf) refusé

`integer_overflow`

entier hors de la plage i64

constraint

`constraint_violated`

cet assert introduit une violation de contrainte (le point fixe dérive false) — delta refusé, session intacte

fixdb

`db_corrupted_checkpoint`

checkpoint de base corrompu : {} — l'état persisté ne se relit pas ; la base est inexploitable en l'état.

`db_corrupted_journal`

journal de base corrompu à la transaction {} — trou interne dans la chaîne d'empreintes. Lance `--db-repair <chemin>` pour tronquer au dernier point valide.

`db_io_error`

erreur disque sur la base `{}` : {} — écriture non durable, opération abandonnée (aucun retry).

`db_locked`

base `{}` verrouillée par un autre processus (un seul écrivain à la fois) — ferme l'autre session, ou rouvre quand elle est libérée.

`db_version_mismatch`

format de base incompatible : version `{}` trouvée, `{}` attendue par ce binaire — ce fichier a été écrit par une autre version de fix.

ilp

`dual_cyclic`

dual(...) pris dans un cycle de récursion positive : {}

`feature_disabled`

déclaration désactivée (pull-driven, cf. backlog) : {}

modules

`cyclic_module_import`

cycle d'imports de modules : {}

`empty_qualification`

qualification vide : {}

`encapsulation_head`

tête {} hors du module courant {}

`end_module_without_begin`

end_module sans module

`import_ambiguity`

{}/{} importé de plusieurs modules : {}

`module_not_found`

module introuvable : {}

`module_not_imported`

module non importé : {}::{}/{}

`nested_module`

module imbriqué interdit : {} dans {}

`not_exported`

prédicat non exporté : {}::{}/{}

`selective_import_not_exported`

import sélectif non exporté : {}::{}/{}

`unclosed_module`

module non fermé : {}

negation

`neg_cyclic`

cycle négatif (programme non stratifiable) : {}

`neg_query_only`

`not {}` (règle `{}`) : ce prédicat n'est pas énumérable (variable de tête liée par un comparateur seul) — sa saturation est incomplète par construction, la nier dériverait du faux. Donne un générateur relationnel à la variable.

`neg_unsafe`

négation non sûre : {} (variable {} non liée)

run

`file_read_error`

lecture de module impossible : {} ({})

`file_write_error`

écriture de fichier impossible : {} ({})

safety

`unsafe_rule`

règle non sûre : {} (variable de tête non liée, {})

`var_in_fact`

variable {} dans un fait (les faits doivent être clos)

serialisation

`expected`

{} attendu (token {}) dans le texte à lire.

`lex_error`

le texte à lire ne passe pas l'analyse lexicale (caractère ou littéral invalide). Corrige le texte source.

`lire_ecrire_arg_not_ground`

{} : l'argument {} n'est pas utilisable en entrée — Lang, Type et Texte doivent être des atomes clos, et le Terme d'ecrire doit être clos (mode (+,+,+,±)). Lie ou corrige cet argument.

`lire_ecrire_bad_arity`

{} attend 4 arguments, reçu {} — forme : {}(Lang, Type, Entree, Resultat).

`lire_ecrire_in_rule`

{} ne peut pas apparaître dans une règle (clause de {}) — but de requête uniquement. Corrige : retire ce littéral et pose-le en requête ?- {}(...).

`lire_ecrire_not_segmented`

requête lire/ecrire mal ordonnée : {} est hors de la forme segmentée. Forme attendue : d'abord les lire(...), puis les littéraux ordinaires, puis les ecrire(...). Réordonne la conjonction.

`lire_ecrire_term_not_of_type`

terme mal typé pour ecrire : {} n'est pas une valeur du type {}. Corrige le terme, ou le type racine passé à ecrire.

`lire_ecrire_type_undeclared`

type non déclaré : {} — le type racine de lire/ecrire doit être un type déclaré. Ajoute sa déclaration type ... = ... ou corrige le nom.

`lire_ecrire_unknown_language`

langage inconnu : {} — aucune déclaration de syntaxe (clause := ou fait syntax/3) pour ce nom dans la session. Déclare le langage ou corrige le nom.

`malformed_embed`

embed mal formé : la surface attendue est un constructeur portant un contenu échappé (spec 41 M3). Vérifie la composition string-embed.

`premature_end`

fin de texte prématurée (token {}) : un opérande ou un délimiteur restait attendu. Complète le texte.

`slots_w4`

déclaration slots ambiguë ({}) : la frontière entre trous juxtaposés n'est pas décidable (garde W4). Ajoute un séparateur ou réordonne les mots-clés.

`syntax_lang_prefix_obsolete`

préfixe de langage `{}:` obsolète pour déclarer une syntaxe — le module EST le langage. Déclare la clause dans un bloc `module(<lang>, [...])` : une clause `Ctor := …` y produit `syntax(<lang>, …)`. Le préfixe est une cérémonie redondante (un discriminant suffit).

`trailing`

{} token(s) en trop après une expression complète (token {}). Retire le surplus ou vérifie les délimiteurs.

`unexpected_head`

symbole inattendu en tête d'expression (token {}) : aucun constructeur du langage ne commence ici. Vérifie le texte ou la syntaxe déclarée.

syntax

`float_malformed`

littéral flottant invalide

`nesting_too_deep`

imbrication trop profonde (limite {})

`reserved_override`

redéfinition interdite de {}::{}/{} (importé de {})

`reserved_underscore`

identifiant réservé : {} (double underscore interdit)

`syntax_clause`

erreur de syntaxe : {}

`unexpected_char`

caractère inattendu : {}

`unexpected_eof`

fin de fichier inattendue : attendu {}

`unexpected_token`

token inattendu : attendu {}, trouvé {}

termination

`eval_decreasing_agg_cycle`

évaluation incomplète : cycle décroissant d'agrégat détecté (certificat en {} passes) — l'agrégat régresse à chaque tour, aucun point fixe

`eval_not_converged`

évaluation incomplète : point fixe non atteint en {} itérations

`eval_strata_unsatisfiable`

évaluation incomplète : ordonnancement des strates d'agrégat insatisfiable ({} prédicats) — configuration inattendue, merci de signaler ce cas

`eval_work_budget`

évaluation incomplète : budget de travail épuisé ({} unités) sans stabilisation — une récursion fabrique des valeurs sans borne

`rule_growing`

terminaison non prouvable : règle croissante {} (position {})

types

`any_type_banned`

`any` interdit comme kind (SLV-INV-NO-ANY-TYPE) sur {} ; laisse le type non déclaré (ouvert) ou donne un kind concret

`duplicate_decl`

déclaration {} dupliquée pour {}

`redeclaration`

redéclaration de {} '{}' — {}

`reserved_kind_name`

`{}` est un nom réservé du système (une classe de types), pas un type — utilise un type déclaré, un nom ouvert, ou `number` (valeurs numériques) ; un nom réservé ne se redéclare pas.

`reserved_pred_name`

`{}` est un nom réservé ({}) — renomme le prédicat. Noms réservés (toute arité) : add, sub, mul, div, mod, compare, max, min, lire, ecrire ; max/min restent libres comme opérateurs d'agrégation.

`subtype_nonground`

requête subtype non close refusée : {}

`type_binder_lowercase`

`type {}({}, …)` : un lieur lie des variables, et une variable de type s'écrit en MAJUSCULE — mets le paramètre en majuscule. La casse porte le sens : majuscule = variable (n'importe quel type), minuscule = LE type nommé.

`type_error`

le prédicat {} attend {}, reçu {}

`type_error_cell`

règle mal typée : {} a la cellule {}, attendu {}

`type_error_depth`

terme trop profond dans {} (limite {})

`type_error_fact`

fait mal typé : {}

`type_error_label_not_allowed`

fait mal typé : `{}`
    position {} : `{}` est une étiquette, mais `{}` n'accepte pas cette forme ici.
    Corrige : mets une valeur du type déclaré pour cette position, ou change ce type.

`type_error_mixed_shapes`

fait mal typé : `{}`
    position {} : `{}` reçoit ici des formes de valeur incompatibles ({} et {}).
    Corrige : uniformise la position, ou déclare sig(`{}`, [...]).

`type_error_multisort`

le constructeur {} appartient à deux types : {} et {}

`type_error_no_sig`

constructeur {} sans signature (dans {})

`type_error_no_signature`

fait mal typé : `{}`
    `{}` n'a pas de signature déclarée — impossible à typer.
    Corrige : déclare sa signature, ex. sig(`{}`, [...]).

`type_error_number_not_allowed`

fait mal typé : `{}`
    position {} : `{}` est un nombre, mais `{}` n'accepte pas cette forme ici.
    Corrige : mets une valeur du type déclaré pour cette position, ou change ce type.

`type_error_rule`

règle mal typée : `{}` — {}

`type_error_structure_not_allowed`

fait mal typé : `{}`
    position {} : `{}` est un terme structuré, mais `{}` n'accepte pas cette forme ici.
    Corrige : mets une valeur du type déclaré pour cette position, ou change ce type.

`type_error_subtype_open_source`

la déclaration subtype({}, {}) part d'un type sans définition : {} n'est déclaré par aucun type. Corrige : déclare type {} = ..., ou retire la déclaration subtype.

`type_error_value_not_in_type`

fait mal typé : `{}`
    position {} : `{}` n'est pas une valeur du type `{}`.
    Corrige : ajoute cette valeur au type, ou utilise une valeur déjà déclarée du type.

`type_error_value_not_in_type_nested`

fait mal typé : `{}`
    position {}, en profondeur ({}) : `{}` n'est pas une valeur du type `{}`.
    Corrige : ajoute cette valeur au type, ou utilise une valeur déjà déclarée du type.

`type_error_wrong_arity`

fait mal typé : `{}`
    `{}` a {} argument(s), mais sa signature en attend {}.
    Corrige : ajuste l'appel, ou la signature sig(`{}`, [...]).

`type_var_free_in_variant`

dans `type {}`, le variant `{}` référence la variable de type `{}` que le lieur ne lie pas — ajoute-la aux paramètres, ou remplace-la par un type nommé.

`unknown_kind`

kind inconnu : {}