Wikipédia abstraite/Z-ID réservés

From Meta, a Wikimedia project coordination wiki
Jump to navigation Jump to search
This page is a translated version of the page Abstract Wikipedia/Reserved ZIDs and the translation is 77% complete.
Outdated translations are marked like this.

liste de diffusion de la Wikipédia abstraite Wikipédia abstraite sur IRC Wikifonctions sur Telegram Wikifonctions sur Twitter Wikifonctions sur Facebook Wikifonctions sur Youtube site web de Wikifonctions Translate

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

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: reserved for future use
  • Z7000 – Z7999: experimental, used for NLG, will be changed
  • Z8000 – Z8999: Testers for each pre-defined function (e.g. Z801 is tested via Z8010, Z8011, Z8012, … Z8019).
  • Z9000 – Z9999: reserved for future use

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: Couple (type générique, donc techniquement une function) : car c’est deux deux.
  • 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

  • Z801Echo: T ➝ T
    returns the input unchanged
  • Z802If: Boolean, T, T ➝ T
    retourne le deuxième argument si le premier est vrai, sinon le troisième ; « si » a deux lettres.
  • Z803Value by key: Key reference, Any ➝ Any
    retourne la valeur par une clé de l’objet ; Z3/Clé.
  • Z805Reify: 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: Error ➝ Any
    take the given error or other metadata and emit it in the function call response envelope.
  • 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)
    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.
  • 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.
  • 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 (page title): wrong namespace
  • Z539 (page title): wrong content type
  • Z540 (language code): invalid language code
  • Z541 (language code): language code not found
  • Z542 (expected type, actual object): expected type, actual object
  • Z543 (type name): type not found
  • 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): key type mismatch

Voir aussi