Abstraktní Wikipedie/Aktualizace/2022-01-13

◀

Aktualizace Abstraktní Wikipedie

▶

Aktualizace fáze η

Šťastný nový rok a vítejte u prvního newsletteru roku 2022!

Když jsme začali pracovat na Wikifunkcích, rozdělili jsme práci na jedenáct funkčních fází, pojmenovaných podle prvních jedenácti písmen řecké abecedy (pojmenování, které se v poslední době proslavilo). V současné době pracujeme na fázi η (eta), jejímž cílem je zcela přepracovat funkční model Wikifunkcí tím, že umožníme použití obecných typů a funkcí.

Na základě diskusí v týmu upřesňujeme kritéria pro dokončení současné fáze, aby byla hmatatelnější. Původní představa o tom, jak ukázat, že jsme fázi dokončili, byla taková, že bychom provedli hodně hlubokou statickou validaci, takže volání funkce, jako např:

(1) if(head([true]), false, true)

by platil, ale

(2) if(head(["text"]), false, true)

by neplatil. Vysvětlení: funkce if vyžaduje jako první argument Boolean, ale head je nyní definována jako head(List) → Object. Takže ve statické analýze if vyžaduje Boolean ale dostává Object. Ale pokud bychom si řekli, že to je v pořádku, tak statická analýza pro obojí projde, ale pro druhý příklad by projít neměla.

Na druhé straně máme kromě statické analýzy i dynamickou analýzu, která probíhá za běhu kódu. Při ní by měl bod (1) projít a vrátit false, zatímco (2) by měl při vyhodnocování vyvolat typovou chybu (např. “if očekává Boolean jako první argument, ale dostal String”).

Rozhodli jsme se prozatím zrušit hloubkovou statickou analýzu. Tu můžeme přidat později, případně po spuštění Wikifunctions.org. Jak vidíte, uživatelé by dostali chybové zprávy tak či onak: jde jen o to, kdy přesně se chyba objeví. Také pokud máte zájem pracovat na těchto nebo podobných tématech, ozvěte se. Vždy rádi zapojíme práci dobrovolníků a dalších externích partnerů.

Místo této statické analýzy jsme se rozhodli zaměřit se na následující schopnosti jako příklady toho, jak bude tato fáze dokončena:

• Being able to implement curry as a composition on the wiki, but without requiring strict static analysis
• Making it possible to create the following three 'user-defined' types on the wiki: positive integer, sign, and integer
• Being able to make a generic wrapper type through composition on the wiki
• Providing a re-designed function editor (though this might be pushed into the next phase)

Let’s dive deeper into each of these capabilities.

Curry

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.

User-defined types

Positive Integer

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)

Sign

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)

Integer

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)

Generic wrapper

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
• Note that all these functions should be possible to be written entirely in user space
• Test by calling something like Unwrap(Boolean)(Wrap(Boolean)(True)) and get True back

Where to next?

There are still quite a few tasks to be done in this phase, but many of the pieces are almost in place for it. Once this phase is complete, we will focus on getting the beta cluster ready for you to play with.

We wish you all the best for the New Year!