Wikifunctions:Z-ID réservés

Le wiki des fonctions précharge actuellement quelques Objets-Z statiques à l’installation. Nous aurons au cours du temps besoin de quelques autres de ces objets.

Cette page concerne l’amusante discussion ayant fait son chemin sur combien de Z-ID nous devrions réserver, ou bien s’ils doivent être contigus et quels devraient être les premiers Z-ID définis. Ce peut aussi être le lieu pour planter quelques « œufs de Pâques », une caractéristique qui s’est avérée assez populaire dans Wikidata.

Notez que, afin de simplifier la discussion, nous ne songeons pas encore à la possibilité future d’avoir des instances fédérées du logiciel faisant fonctionner le wiki des fonctions, ni de comment cela fonctionnera. Nous ne songeons qu’à quels Z-ID devraient être réservés pour le wiki des fonctions lui-même.

Les Z-ID réservés devraient-ils être contigus ?

Oui.

Il y a une certaine simplicité à dire « tous les Z-ID à 4 chiffres ou moins sont réservés ».

Il y a aussi le modèle hybride consistant à réserver tous les Z-ID en dessous d’un certain numéro et à réserver en plus certains Z-ID comme œufs de Pâques ou pour des raisons spécifiques (comme ce qu’a fait Wikidata).

Combien de Z-ID devrions-nous réserver ?

Réservons tous les Z-ID avec quatre chiffres ou moins.

Tous les objets essentiels seraient dans les Z-ID avec trois chiffres ou moins et nous gardonsles Z-ID à quatre chiffres pour les langues.

Ceci suit sommairement les propositions faires par des membres de la communauté sur la page de discussion et sur Phabricator. En particulier, nous ne compacterons également pas cet espace.

Z-ID actuellement réservés

Tracked in Phabricator:
Task T258914

Ce qui suit est sujet à changer et reste ouvert aux discussions. Les quelques explications qui suivent peuvent aider à les rendre mnémoniques (bien qu’il ne devrait pas être nécessaire de les mémoriser).

See Wikifunctions:Reserved ZIDs/all for a list of currently pre-defined objects.

Plages

Nous réservons certains espaces pour certains types d’objets.

• Z1 – Z99: types essentiels. (Voir § Types essentiels ci-dessous.)
• Z100 – Z199: validateurs pour les types essentiels (c’est-à-dire que pour chaque type essentiel, +100 donne son validateur), par ex. Z104 est le validateur pour Z4/Type.
• Z200 – Z299: mises en œuvre intégrées pour les validateurs des types essentiels (c’est-à-dire que Z204 est la mise en œuvre intégrée pour le validateur de Z4/Type).
• Z300 – Z399: non affectés pour le moment.
• Z400 – Z499: réservés à l’usage local.
• Z500 – Z599: types d’erreur essentiels (Z5xx parce que Z5 est une erreur). (Voir § Types d’erreur essentiels ci-dessous.)
• Z600 – Z699: langages de programmation essentiels (Z6xx parce que Z61 est un langage de programmation)
• Z700 – Z799: non affectés pour le moment.
• Z800 – Z899: définition des fonctions essentielles avec leurs mises en œuvres intégrées (Z8xx car Z8 est une fonction) (Voir § Fonctions essentielles ci-dessous.)
• Z900 – Z999: mises en œuvre intégrées pour les fonctions essentielles (elles sont à +100 de leur Z8xx respectif).
• Z1000 – Z1999: pour les langues ?
• Z2000 – Z6999: réservé pour l'utilisation dans le future
• Z7000 – Z7999: expérimentaux; utilisées pour NLG; seront mofifiés.
• Z8000 – Z8999: Testers for each pre-defined function (e.g. Z801 is tested via Z8010, Z8011, Z8012, … Z8019).
• Z9000 – Z9999: réservé pour une utilisation future

Types essentiels

• Z1: Objet Z (Type) : la racine.
• Z2: Object persistant (Type) : tout ce qui est sur le wiki est un Z2, c’est pourquoi il a un Z-ID aussi petit.
• Z3: Clé (Type) : car le mot key a trois lettres en anglais.
• Z4: Type (Type) : car le mot type a quatre lettres en anglais.
• Z5: Erreur (Type) : car le mot error a cinq lettres en anglais. (Voir § Types d’erreur essentiels ci-dessous.)
• Z6: Chaîne (Type) : car le mot string a six lettres en anglais.
• Z7: Appel de fonction (Type) : car les appels de fonctions sont la magie principale du système et 7 est un nombre magique. Il est également proche de Z8.
• Z8: Fonction (type générique, donc techniquement une fonction) : car le mot function a huit lettres en anglais. (Voir § Fonctions essentielles ci-dessous.)
• Z9: Référence (Type) : car le mot reference a neuf lettres en anglais.
• Z10: Liste (type générique, donc techniquement une fonction) : car c’est le premier nombre ayant deux chiffres.
• Z11: Texte monolingue (Type) : car c’est juste en une langue, et il y a un un dans le nom.
• Z12: Texte multilingue (Type) : car c’est plus que Z11.
• Z13: liste vide (Liste) : la nature a horreur du vide et les gens n’aiment pas le 13.
• Z14: Mise en œuvre (Type) : car le mot implementation a quatorze lettres en anglais.
• Z15: Pas encore attribué.
• Z16: Code (Type) : aucune bonne raison, c’est proche de Z14 et de Z61/Langage de programmation.
• Z17: Déclaration d’argument (Type).
• Z18: Référence d’argument (Type).
• Z19: Pas encore attribué.
• Z20: Testeur (Type) : car 20/20 est la vision parfaite et les tests rendent les erreurs visibles.
• Z21: Unité (Type).
• Z22: Résultat d’évaluation (Type).
• Z23: Rien (Type).
• Z24: void (Unit).
• Z25: Pas encore attribué.
• Z26: Pas encore attribué.
• Z27: Pas encore attribué.
• Z28: Pas encore attribué.
• Z29: Pas encore attribué.
• Z30: Pas encore attribué.
• Z31: Monolingual textset (Type).
• Z32: Multilingual textset (Type): because it's an extension of Z31.
• Z33: Pas encore attribué.
• Z34: Pas encore attribué.
• Z35: Pas encore attribué.
• Z36: Pas encore attribué.
• Z37: Pas encore attribué.
• Z38: Pas encore attribué.
• Z39: Référence de clé (Type) : car Z3/Clé Z9/Référence.
• Z40: Booléen (Type) : car Boole a commencé à publier dans les années 40.
• Z41: vrai (Booléen).
• Z42: faux (Booléen).
• Z43: Pas encore attribué.
• Z44: Pas encore attribué.
• Z45: Pas encore attribué.
• Z46: Pas encore attribué.
• Z47: Pas encore attribué.
• Z48: Pas encore attribué.
• Z49: Pas encore attribué.
• Z50: Type d’erreur (Type) : car Erreur est Z5.
• Z60: Langue naturelle (Type).
• Z61: Langage de programmation (Type) : car Z16 est du code.
• Z80: Octet (Type) : parce que c’est un octet.
• Z84: Union (Type).
• Z85: Pas encore attribué.
• Z86: Caractère (Type) : car ce n’est pas exactement un Z80/Octet, mais davantage comme une Z6/Chaîne.
• Z99: Quote (Type) : car cela ressemble un peu au signe de fin de citation en anglais.

Fonctions essentielles

• Z801 Echo: T ➝ T

  returns the input unchanged

• Z802 If: Boolean, T, T ➝ T

  retourne le deuxième argument si le premier est vrai, sinon le troisième ; « si » a deux lettres.

• Z803 Value by key: Key reference, Any ➝ Any

  retourne la valeur par une clé de l’objet ; Z3/Clé.

• Z805 Reify: Any ➝ List(Pair(Key reference, Any))

  transforme tout objet en une liste ordonnée de paires clé – valeur ; « reify » a cinq lettres en anglais.

• Z808 Abstract: List(Pair(Key reference, Any)) ➝ Any

  transforme une liste ordonnée de propriétés en un objet ; « abstrait » a huit lettres.

• Z810 Prepend element to list: T, List(T) ➝ List(T)

  insère un objet en tête d’une liste ordonnée d’objets (parce que Z10 est une liste).

• Z811 First element: List(T) ➝ T

  obtient le premier élément d’une liste ordonnée d’objets (car Z10 est une liste et nous en prenons le premier).

• Z812 List without first element: List(T) ➝ List(T)

  obtient la liste ordonnée d’objets, réduite sans son premier élément (car Z10 est une liste et nous en prenons le second, le reste).

• Z813 Empty: List(T) ➝ Boolean

  retourne si une liste ne contient aucun élément (car Z13 est la liste vide).

• Z820 Trigger Metadata: String, Any ➝ Any

  take the given value (an error or other metadata) and emits it in the function call response envelope under the name of the String input.

• Z821 First: Pair(T1, T2) ➝ T1

  extrait la première valeur d’un couple (car Z22 est un couple).

• Z822 Second: Pair(T1, T2) ➝ T2

  extrait la seconde valeur d’un couple (car Z22 est un couple).

• Z844 Boolean equality: Boolean, Boolean ➝ Boolean

  returns true if the two inputs are the same, false otherwise

• Z860 Language code to language: String ➝ Language

  takes a language code given as a string and returns a natural language object

• Z866 String equality: String, String ➝ Boolean

  returns true if the two inputs are the same, false otherwise

• Z868 Convert: String ➝ List(Character)

  convert a string into a list of Characters, because Z6/String and Z86/Character.

• Z873 Map: Function, List ➝ List

  Returns a list where each of the Z1/objects of an input Z881/List has been processed by the given Z8/Function

• Z876 Reduce: Function, List, Object ➝ Object

  Returns a value after running the given Function on each object of the List, starting with the given Object

• Z868 Convert: String ➝ List(Character)

  convertit une chaîne en liste de Caractères, car Z6/Chaîne et Z86/Caractère.

• Z881Typed list: Type ➝ Type

  takes a type and returns a type of a list of elements of that type

• Z882Typed pair: Type, Type ➝ Type

  takes two types and returns a type representing a pair of these

• Z883Map: … ➝ …

  …

• Z884Union: T, T ➝ T

  takes two types and returns a type that accepts either

• Z885Error type to type: Error type ➝ Type

  takes an error type and creates a type out of it

• Z886Convert: List*(Character) ➝ String

  convertit une liste de Caractères en une chaîne, car Z86/Caractère et Z6/Chaîne.

• Z887Reduce: … ➝ …

  …

• Z888 Same: Character, Character ➝ Boolean

  compare deux caractères et retourne s’ils sont égaux.

• Z899 Unquote: Quote ➝ Any

  dé-cite un Objet-Z, car Z99/Citation.

Types d’erreur essentiels

• Z501 (message d’erreur, entrée) : erreur de syntaxe.
• Z502 (sous-type, valeur) : mal formé, pointe vers Z52x ou Z53x.
• Z503 (nom de fonction) : pas encore mis en œuvre.
• Z504 (zid) : Z-ID non trouvé.
• Z505 (attendu, effectif, arguments) : désaccord sur le nombre d’arguments.
• Z506 (attendu, effectif, argument) : désaccord des types d’arguments.
• Z507 (appel de fonction) : erreur lors de l’évaluation.
• Z508 (objet) : clés en conflit.
• Z509 (errors): List of errors
• Z510 (aucun) : néant.
• Z511 (référence de clé, objet) : clé non trouvée.
• Z512 (objet) : erreur Z9.
• Z513 (objet résolu) : objet résolu sans Z2K2.
• Z514 (mise en œuvre) : mise en œuvre intégrée inexistante.
• Z515 (mise en œuvre) : ID erroné de mise en œuvre intégrée.
• Z516 (clé, valeur erronée) : erreur de valeur de l’argument.
• Z517 (expected type, actual type, returned value, propagated error): Return type mismatch
• Z518 (expected type, object, propagated error): Object type mismatch
• Z519 (object): Undefined list type
• Z520 (object): Wrong list type
• Z521 (valeur incorrecte) : les Objets-Z ne doivent pas être numériques, booléennes ou nulles.
• Z522 (index erronée dans le tableau, erreur propagée) : élément de tableau mal formé.
• Z523 (objet) : clé Z1K1 manquante.
• Z524 (valeur de Z1K1) : la valeur de Z1K1 ne doit pas être une chaine ni un tableau.
• Z525 (clé) : clé non valide.
• Z526 (clé, erreur propagée) : valeur mal formée.
• Z531 (objet complet) : un objet Z6 doit avoir 2 clés.
• Z532 (objet complet) : objet Z6 sans clé Z6K1.
• Z533 (valeur de Z6K1) : la valeur de Z6K1 doit être une chaine.
• Z534 (objet complet) : un objet Z9 doit avoir 2 clés.
• Z535 (objet complet) : objet Z9 sans clé Z9K1.
• Z536 (valeur de Z9K1) : la valeur de Z9K1 doit être une chaine en JSON.
• Z537 (valeur de Z9K1) : la valeur de Z9K1 semble être une référence.
• Z538 (titre de la page) : espace de nom incorrect
• Z539 (titre de la page) : type du contenu incorrect
• Z540 (code de langue) : code de langue invalide
• Z541 (code de langue) : code de langue non trouvé
• Z542 (type attendu, type obtenu) : type attendu, objet obtenu
• Z543 (nom de type) : type non trouvé
• Z544 (type zid, type name, existing type name): conflicting type names
• Z545 (type zid, type name, existing type zid): conflicting type Zids
• Z546 (type zid, type name): builtin type not found
• Z547 (input): invalid format
• Z548 (error message, input): invalid JSON
• Z549 (reference value): invalid ZReference
• Z550 (reference value): unknown ZReference
• Z551 (key, expected type, actual type): schema type mismatch
• Z552 (index, expected type, actual type): array element type mismatch
• Z553 (zobject): disallowed root type
• Z554 (clashing ZID, language): label clashes with another ZObject's label
• Z555 (ZID, title): mis-matched ZID and page title
• Z556 (title): invalid page title
• Z557 (error message): user does not have permission
• Z558 (langage de programmation) : langage de programmation invalide
• Z559 (none): user not permitted to evaluate function
• Z560 (evaluation result): invalid evaluation result
• Z561 (propagated error): invalid evaluation request
• Z562 (missing property): incomplete evaluation request
• Z563 (call): call by non-reentrant executor
• Z564 (contents): invalid executor response
• Z565 (missing property): Incomplete executor request
• Z570 (orchestrator rate limit): reached rate limit in orchestrator
• Z571 (evaluator rate limit): reached rate limit in evaluator
• Z572 (recursion limit, function name): reached recursion limit in orchestrator
• Z573 (recursion limit, function name): reached recursion limit in evaluator
• Z574 (time limit): reached time limit in orchestrator
• Z575 (time limit): reached time limit in evaluator

Voir aussi

• Vue générale des notes