Abstract Wikipedia/Updates/2020-11-25

◀

Abstract Wikipedia Updates

▶

Every Object in Wikifunctions will be identified by its Z-ID, similar to the Q-IDs and L-IDs of Wikidata for Items and Lexemes, respectively.

Whereas most of the Z-IDs will be simply assigned consecutively, we plan to have a few intentionally chosen Z-IDs, just as with Q-IDs and L-IDs. Unlike with Q-IDs and L-IDs the goal of these is less for them to be “Easter eggs”, but rather to be mnemonic and to help with remembering them.

No, no, don’t worry — you shouldn’t be remembering all the Z-IDs that you need to use. The interface should hide most of the Z-IDs. But sometimes, either in early versions of the system, when the interface isn’t sufficiently complete yet, or later in some debugging tasks or when inspecting or creating some messages on the wire, it might be helpful to have core Z-IDs be ever so slightly easier to recall than entirely arbitrary assignments.

I invite you all to join us in finding good Z-IDs for the core Objects of Wikifunctions. We will be coalescing on the solution on this page: Reserved Z-IDs.

The page discusses and lists:

• Should there be a contiguous block of Z-IDs reserved, e.g. all Z-IDs with four digits or fewer (or maybe three or fewer? Just two or one?)
• Which Z-IDs should be reserved?
• What should these Z-IDs be standing for?
• What are the Objects that should get pre-assigned Z-IDs?

Here are a few thoughts that went with the current status of assigned Z-IDs in the Function Model (but you will see that the page above does not always agree with these thoughts).

We tried to minimize the number of reserved Z-IDs, and just reserve the Z-IDs from Z1 to Z99. That’s tight. By extending them to Z999 or Z9999 we would have more space.

The Z-IDs from Z1 to Z25 were mostly for the basic types of the Function Model. These include Object, Type, Function, Implementation, Error, String, List, etc. After that we thought about assigning a block of Z-IDs for the fifteen or so initial Functions, and, twenty above them, their respective initial Builtin Implementations, e.g. having “if” be Z31 and the builtin implementation of “if” be Z51. Besides that, we need a number of reserved Z-IDs for certain error codes, for languages, and for the Boolean values True and False.

Here are a few thoughts on how some of the basic Types were assigned Z-IDs — mostly based on the length of the English label:

• Z1 : Object (Type) : because everything starts here.
• Z2 : Persistent object (Type) : everything on the wiki is a Z2, that's why this has such a low Z-ID.
• Z3 : Key (Type) : because the word “key” has three letters in English.
• Z4 : Type (Type) : because the word “type” has four letters in English.
• Z5 : Error (Type) : because the word “error” has five letters in English.
• Z6 : String (Type) : because the word “string” has six letters in English.
• Z7 : Function call (Type) : because function calls are the main 'magic of the system, and 7 is a magic number. It is also close to Z8.
• Z8 : Function (generic type, thus technically a function) : because function has eight letters in English.
• Z9 : Reference (Type) : because the word reference has nine letters in English.
• Z10 : List (generic type, thus technically a function) : because it's the first number that has two digits.
• Z11 : Monolingual text (Type) : because it is just one language, and there's a one in the name.
• Z12 : Multilingual text (Type) : because it's an extension of Z11.
• Z14 : Implementation (Type) : because the word implementation has fourteen letters in English.
• Z20 : Tester (Type) : because 20/20 is perfect vision, and tests make errors visible.
• Z99 : Quote (Type) 

Another basic Type that still needs an assignment is Boolean, and possibly others.

A list of the currently suggested initial fifteen Functions:

• if: Boolean, T, T ➝ T
• value by key: Key reference, T ➝ U
• reify: Any ➝ List(Pair(Key reference, Any))
• abstract: List(Pair(Key reference, Any)) ➝ Any
• head: List(T) ➝ T
• tail: List(T) ➝ T
• empty: List(T) ➝ Boolean
• cons: T, List(T) ➝ List(T)
• unquote: Quote ➝ Any

Additionally to that we also need a validator function for most of the basic Types. There is a task about the basic Functions and Types on Phabricator: T261474.

These are all just suggestions, and we are happy to see them discussed on wiki. Please make further suggestions for reserved Z-IDs there, either for mnemonic purposes or also for genuine easter eggs. I am sure that you will come up with much better and more interesting suggestions than we are. So, let us know your ideas and see you next week with some news.