release notes

Datastore 120 (after 119.2)

• model 109 implementation

• provided interface implementation language: a state filter ?'s' in a collection expression is part of the dependency chain of that collection, so a reference into the collection must reach the node through the same filter: ``` ‘C of A in s’: collection = ( ‘’ = root .’R-A in s’&’in s’ .’C’* as $ ( ) // chain: context >’R-A’ ?’s’ .’C’* )

// old (accepted: the filter was dropped from the chain): ‘ref-c-s’: text -> .’C of A in s’[] = from ‘’ [ root >’R-A’ >’R-C’ ]

// new (the expression takes the same filter): ‘ref-c-s’: text -> .’C of A in s’[] = from ‘’ [ root .’R-A in s’&’in s’ >’R-C’ ]

- provided interface implementation language: a state rule (`.'sg'?'s'.&'rule'`) and a reference whose target path ends in a filter (`'R-A-s': text -> .'A'[] .'sg'?'s'`) contribute that same state step, so a reference expression may not route around them:

‘D via R-A-s’: collection = ( ‘’ = root >’R-A-s’.&’c’.’D’* as $ ( ) // chain: context >’R-A-s’ ?’s’ >’R-C’ .’D’* )

// old (accepted): an unfiltered reference to some ‘A’ ‘ref-d’: text -> .’D via R-A-s’[] = from ‘’ [ root >’R-A’>’R-C’>’R-D’ ]

// new: ‘ref-d’: text -> .’D via R-A-s’[] = from ‘’ [ root >’R-A-s’.&’c’>’R-D’ ]

- provided interface implementation language: a matrix collection applies the state filters of the collection it is keyed by:

‘C of A in s’: collection = ( ‘’ = root .’R-A in s’&’in s’ .’C’* as $ ( ) ) ‘mat’: collection -> .’C of A in s’ = ( ‘’ = root >’R-A’.’C’* as $ ( ) // old ‘’ = root .’R-A in s’&’in s’ .’C’* as $ ( ) // new )

- provided interface implementation language: the entries of a collection must be distinct nodes. This is now a rule on the branch expression as a whole instead of a rule on its last step, so the same implementations are rejected with a different message:

‘c2’: collection -> .’c1’ = ( ‘’ = $ .’c2’* >’r1’ as $ ( ) // two ‘c2’ entries may point at one ‘c1’ )

// old: no valid ‘unique result nodes’ found for ‘dependency’ ( at >’r1’ ) // new: no valid ‘unique entries’ found for ‘expression’ ( at the branch expression )

For a collection with a key constraint (`collection -> .'Source'`) the step that breaks the uniqueness is marked as well, so the error points at the navigation that has to change.

- provided interface implementation language: the check covers every branch expression, including entry lookups after a collection step. A lookup whose value is not the key of the entry the expression iterates is rejected:

/* application model: ‘X’: collection [‘k’] { ‘k’: text ‘r’: text -> ^ .’C0’[] ** ‘rb’: text -> ^ .’C0’[] where ‘C1 of r’ -> ^ .’C1’>[ >’r’ ] } */

‘E after collection’: collection = join - ( // ERROR: ‘r’ is not the key of ‘X’, so two ‘X’ entries reach the same ‘C1’ and the ‘E’ entries repeat ‘’ = root .’X’* .’rb’&’C1 of r’ .’E’* as $ ( ) )

- provided interface implementation language: a containment rule or a node path lookup after a collection step is now accepted when it produces distinct entries. Previously every lookup after a collection step was rejected ("only reference steps are supported after a collection step"):

/* application model: ‘Y’: collection [‘k’] { ‘k’: text -> ^ .’C0’[] ** ‘rb’: text -> ^ .’C0’[] where ‘C1 of k’ -> ^ .’C1’>[ >’k’ ] } */

‘E after collection by key’: collection = join - ( ‘’ = root .’Y’* .’rb’&’C1 of k’ .’E’* as $ ( ) // distinct ‘Y’ entries find distinct ‘C1’ entries ) ‘D via key’: collection = join - ( ‘’ = root .’Y’* >’k’.’D’[ root >’R-Z’ ] as $ ( ) // each ‘Y’ entry looks up in its own ‘D’ )

- provided interface implementation language: a graph step after a collection step is accepted. An ordered graph maps distinct entries onto distinct predecessors, so the result nodes stay distinct. Repeated steps in the same graph are fine; a plain sibling step and steps in two different graphs are rejected:

/* application model: ‘A’: collection [‘k’] ‘G’: ordered-graph .’first’ ( ?’yes’ || ?’no’>’prev’ ) */

‘A via prev’: collection -> .’A’ = ( ‘’ = $’r’.’A’* .’first’?’no’>’prev’ as $ ( ) // accepted ) ‘A via sib’: collection -> .’A’ = ( ‘’ = $’r’.’A’* >’sib’ as $ ( ) // ERROR: two ‘A’ entries can have the same sibling )

- provided interface implementation language: a `where` rule that only takes parent steps after a collection step is rejected under the name `context within child scope` (was `unique result nodes after parent steps`):

’’ = $ .’c1a’* .’c1b’* .’kb’&’root’ ( ) // ERROR: the rule climbs out of the last collection step

- provided interface implementation language: in a collection expression, a binding followed by more steps ends the line, so `as $'order'` followed by `.'Documents'` is no longer read as the variable step `$'order'.'Documents'`. When the chain splits, it starts on the line after the `=`. A chain that fits on one line and only binds at its end keeps its layout. A chain followed by `where` rules, or longer than 132 columns, also starts on the line after the `=`. The meaning of an implementation does not change and existing files still compile; `./alan upgrade` reformats every system, and by hand `.alan/devenv/platform/project-compiler/tools/pretty-printer .alan/devenv/system-types/datastore/language --allow-unresolved -C systems/<sys>` does.

// old ‘Documents’ = root .’Orders’* as $’order’.’Documents’* as $’document’ (

// new ‘Documents’ = root .’Orders’* as $’order’ .’Documents’* as $’document’ ( ```