The rules for the context functions (Feel.Analysis.Images, D-170; Feel.Builtin.Context): context, context merge,
context put, get entries and get value.
The signatures say Any | Null for most of them, and a context is a context: the rules say what the entries of the one
that is given make of the result, and when it is null.
| Call | The type of the result |
|---|---|
get value(m, key) | the type of the entry key of m, for each key the type of key has; null for a key a closed context does not list; Any or null for one that an open context does not |
get entries(m) | the list of the entries of a closed context, a context {key, value} for each (the list that has an element if it lists one); a list for an open one |
context put(m, key, value) | the context m with the entry key set to the type of value, for each key (closed stays closed); any context for a key that is not known |
context put(m, keys, value) | a context, and null where the path is not there |
context merge(ms) | a context, and null unless every item of the list is one; a context alone is itself |
context(entries) | a context, and null unless every item has a string key and a value, and the keys differ |
A context is a type with entries ({:context, entries} is open, it has at least these, {:closed_context, entries} is
closed, it has these and no others, D-65), and the entries of a type are present: an entry that may be absent is not a
thing a type says. So the result of get value for a key that the closed type lists is the type of the entry, and for one
that it does not list is null, and not an error (Feel.Builtin.Context).
Structural readers inspect excluded positive bases too. For context(entries), an open context
may supply key and value even when its type does not list them; only a closed context proves
such entries absent.
A list of one context is that context (section 10.3.2.9.4), and so a list type is a context or null, as the list has one
item or not: a type does not say how many. The argument that takes a list (context merge, context) takes a context as the
list of it.
What the rules do not say: the order of the entries (a type is a map), which entries a merge of several contexts has (they
may all be there or not, and a type has no entry that is not there for sure), and the path of context put with a list of
keys, which a list type does not give in order.