The wikiversion of this newsletter can be found here:
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
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
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 Z1-Z99. That’s tight. By extending to Z999 or Z9999 we would have
The Z-IDs Z1-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 ZID.
- 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
- Z6: *String* (Type) : because the word string has six letters in
- 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
- 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
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 <https://phabricator.wikimedia.org/T261474>
These are all just suggestions, and we are happy to see them discussed on
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.