Wikipédia abstraite/Mises à jour/2022-01-13

Actualités de la Wikipédia abstraite

Mise à jour sur la phase η (êta).

Bonne et heureuse nouvelle année et bienvenue au premier bulletin d’actualités de 2022 !

Lorsque nous avons commencé le travail sur Wikifonctions, nous l’avons divisé en onze phases fonctionnelles, nommées d’après les onze premières lettres de l’alphabet grec (un schéma de nommage qui a reçu de la notoriété récemment). Nous travaillons actuellement sur la phase η (êta), avec l’objectif d’entièrement refaire le modèle fonctionnel de Wikifonctions, en permettant les types génériques et les fonctions génériques.

Suite aux discussions avec l’équipe, nous raffinons le critère de complétion pour la phase actuelle, afin de la rendre plus tangible. À l’origine, l’idée sur comment montrer que nous avions achevé la phase était que nous n’en ferions pas beaucoup en terme de validation statique très profonde, de sorte qu’un appel de fonction tel que :

(1) si(tête([vrai]), faux, vrai)

passerait la validation, mais

(2) si(tête([“texte”]), faux, vrai)

ne la passerait pas. Pour l’expliquer : la fonction si demande un Booléen en premier argument, mais tête est actuellement définie comme tête(Liste) → Objet. Donc dans une analyse statique, si demande un Booléen mais obtient un Objet. Mais si nous disions que cela était correct, l’analyse statique pour à la fois (1) et (2) passerait — mais (2) ne devrait pas passer.

D’autre part, à côté de l’analyse statique nous avons l’analyse dynamique, qui se produit lors de l’exécution du code. Dans cette dernière, (1) devrait passer et retourner faux, alors que (2) devrait lever une erreur de type durant l’évaluation (quelque chose comme « si attend une valeur de type Booléen dans le premier argument, mais a obtenu une valeur de type Chaîne »).

Nous avons décidé de sortir pour le moment l’analyse statique du champ du plan actuel. C’est quelque chose que nous pouvons ajouter plus tard, éventuellement même après le lancement de Wikifunctions.org. Comme vous pouvez le voir, les utilisateurs obtiendraient des messages d’erreur d’une façon ou d’une autre : c’est juste une question de quand l’erreur sera levée. Également, si vous êtes intéressé à travailler sur ceci ou sur d’autres sujets similaires, veuillez vous signaler. Nous serons toujours ravi d’intégrer le travail des bénévoles et des autres partenaires externes.

Au lieu de cette analyse statique, nous avons décidé de nous concentrer sur les capacités suivantes comme exemples montrant comment la phase aura été achevée :

être capable de mettre en œuvre la curryfication comme une composition sur the wiki, mais sans nécessiter une analyse statique stricte ;
rendre possible la création des trois types « définis par l’utilisateur » sur le wiki : entier positif, signe et entier ;
être capable de créer un type emballeur générique au moyen de la composition sur le wiki ;
fournir un éditeur de fonction reconçu (bien que ceci puisse être repoussé à la phase suivante).

Plongeons plus profondément dans chacune de ces capacités.

Curryfication

For this to work, a user must be able to use a function as an argument, and use that function for a function call in the implementation of curry. What is curry? Curry is a standard function in computer science that takes a function f and another object x and runs the function on the object. The standard form is that the function f has two arguments, the first one being of the type of x, and the 'output' is a call to the function f with the second argument preset to the value x. Example: given a function that appends a string to another string, I could create a new function “add s to end” by calling curry(append, "s"). We want to make it possible to define and call such a function.

Types définis par l’utilisateur

Entier positif

The following things will need to be possible:

Create a new type, Positive Integer, with a single key value of type String
Create a function to validate Positive Integer
- If value contains a character which is not a digit (0-9), the validator raises a user-created error with the non-digit character
- If value contains leading zeros and is not just a single zero, the validator raises a user-created error
- If value is an empty string, the validator raises a user-created error
Connect the validator to the Positive Integer type
Create the following eight functions:
- Is zero: Positive Integer → Boolean (returns True if the argument is zero and False otherwise)
- Successor: Positive Integer → Positive Integer (returns the argument increased by one)
  - Provide implementations in JavaScript (BigInt) and Python (bignum)
- Predecessor: Positive Integer → Positive Integer (returns the argument decreased by one, raises an error in case the argument is zero)
  - Provide implementations in JavaScript (BigInt) and Python (bignum)
- Positive Integer: String → Positive Integer (constructor)
- Positive Integer as String: Positive Integer → String (deconstructor)
- Equal Positive Integer: Positive Integer, Positive Integer → Boolean (whether the two numbers have the same value)
- Greater Than: Positive Integer, Positive Integer → Boolean (whether the first number is bigger than the second)
- Lesser Than: Positive Integer, Positive Integer → Boolean (whether the second number is bigger than the first)

Signe numérique

The following things will be possible, related to the mathematics term "sign":

Create a new type, Sign, with a single key identity of type Sign
Create the three possible values of type Sign, i.e. positive, negative, and neutral
Create a function to validate Sign
- If the value is not one of the expected three values, raise an error
Connect the validator to the Sign type
Create the following function:
- Equal sign: Sign, Sign → Boolean (returns True if the two arguments have the same value)

Entier

The following things will be possible:

Create a new type, Integer, with two keys, absolute value of type Positive Integer and sign of type Sign
Create a function to validate Integer
- Ensure that both keys are validated
- If sign is neutral and absolute value is not zero, or vice versa, raise an error
Connect the validator with the Integer type
Create the following six functions:
- Integer: Positive Integer, Sign → Integer (constructor)
- Absolute value: Integer → Positive Integer (deconstructor)
- Sign: Integer → Sign (deconstructor)
- Equal Integer: Integer, Integer → Boolean (whether the two numbers have the same value)
- Greater Than: Integer, Integer → Boolean (whether the first number is bigger than the second)
- Lesser Than: Integer, Integer → Boolean (whether the second number is bigger than the first)

Emballeur générique

A generic wrapper is a function that takes a type and returns a newly constructed type that has a single key with a value of that type. Wrappers may be useful for example to make sure that we don’t accidentally treat something as a number that looks a lot like a number. It is also useful as a test case because it is a rather simple generic type.

Create a function that creates the generic type, i.e. Wrap Type: Type → Type
Create a generic constructor function, i.e. Wrap: Type T → Function which is a function that returns a function of signature T → Wrap Type(T)
Create a generic deconstructor function, i.e. Unwrap: Type T → Function which is a function that returns a function of signature Wrap Type(T) → T
Store a literal of type Wrap Type(Boolean) as an object on the wiki
Write a generic function that creates a function that works with Wrap Type(T), e.g. Wrapped Equality: Type T → λ: Wrap(T), Wrap(T) → Boolean
Notez que toutes ces fonctions devraient pouvoir être écrites entièrement dans l’espace utilisateur.
Test by calling something like Unwrap(Boolean)(Wrap(Boolean)(True)) and get True back

Et après ?

Il reste encore un certain nombre de tâches à faire dans cette phase, mais nombre des pièces sont pratiquement en place pour celle-ci. Une fois cette phase achevée, nous nous concentrerons à préparer la grappe de serveurs afin que vous puissiez jouer avec.

Nous vous souhaitons à tous le meilleur pour la nouvelle année !