openlists

Values › StructsIn the specification

{a: 1} ⊑ {}
{a: 1, b: 1} ⊑ {a: 1}
{a: 1} ⊑ {a: int}
{a: 1, b: 1.0} ⊑ {a: int, b: number}

{} ⋢ {a: 1}
{a: 2} ⋢ {a: 1}
{a: 1} ⋢ {b: 1}

StructLit       = "{" { Declaration "," } "}" .
StructLit       = [ "#" ] "{" { Declaration "," } "}" .
Declaration     = Field | Ellipsis | Embedding | LetClause | attribute .
Ellipsis        = "..." [ Expression ] .
Embedding       = Comprehension | Expr .
Field           = Label ":" { Label ":" } Expr { attribute } .
Label           = LabelExpr [ Alias ] .
LabelExpr       = LabelName [ "?" | "!" ] | "[" Expr "]" .
LabelName       = identifier | simple_string_lit | "(" Expr ")" .

attribute       = "@" identifier "(" attr_tokens ")" .
attr_tokens     = { attr_token |
                    "(" attr_tokens ")" |
                    "[" attr_tokens "]" |
                    "{" attr_tokens "}" } .
attr_token      = /* any token except '(', ')', '[', ']', '{', or '}' */

Expression                             Result
{a: int, a: 1}                         {a: 1}
{a: int} & {a: 1}                      {a: 1}
{a: >=1 & <=7} & {a: >=5 & <=9}        {a: >=5 & <=7}
{a: >=1 & <=7, a: >=5 & <=9}           {a: >=5 & <=7}

{a: 1} & {b: 2}                        {a: 1, b: 2}
{a: 1, b: int} & {b: 2}                {a: 1, b: 2}

{a: 1} & {a: 2}                        _|_

Values › Structs › Closed structsIn the specification

S: {
    field1: string
}

S1: S & { field2: "foo" }

// S1 is { field1: string, field2: "foo" }


A: {
    field1: string
    field2: string
}

A1: A & {
    feild1: "foo"  // "field1" was accidentally misspelled
}

// A1 is
//    { field1: string, field2: string, feild1: "foo" }
// not the intended
//    { field1: "foo", field2: string }

Syntactically, structs are closed explicitly with the close builtin or implicitly and recursively by definitions.

Syntactically, structs are closed explicitly with the close builtin or implicitly and recursively by definitions. With the experimental @experiment(openlists) attribute, a struct literal prefixed with #, as in #{field1: string}, is a closed struct literal: it is closed at its own level, as with close, and, unlike the argument of close, its fields keep the closedness of an enclosing definition.

A: close({
    field1: string
    field2: string
})

A1: A & {
    feild1: string
} // _|_ feild1 not defined for A

A2: A & {
    for k,v in { feild1: string } {
        k: v
    }
}  // _|_ feild1 not defined for A

C: close({
    [_]: _
})

C2: C & {
    for k,v in { thisIsFine: string } {
        "\(k)": v
    }
}

D: close({
    // Values generated by comprehensions are treated as embeddings.
    for k,v in { x: string } {
        "\(k)": v
    }
})

Values › ListsIn the specification

ListLit       = "[" [ ElementList [ "," ] ] "]" .
ElementList   = Ellipsis | Embedding { "," Embedding } [ "," Ellipsis ] .

Lists that are open by default are an experimental feature, enabled per file with the @experiment(openlists) attribute. With it, a list literal without a trailing ... is open, like a struct, and a list is closed where a struct would be: within a definition, including a hidden definition, and when closed with the close builtin. A closed list admits only its own elements and those matched by its ellipsis. Whether a list is open is determined by the file of the expression that created it: a list literal by its own file, and the result of a builtin by the file of the call.

@experiment(openlists)
 
y: [3]
y: [_, 4] // [3, 4]
 
#Pair: [int, int]
p: #Pair & [1, 2, 3] // _|_: index 2 is not allowed

With the experiment, a list literal prefixed with #, as in #[1, 2], is a closed list literal: it is closed at its own level, as a list literal is without the experiment, and its elements are not closed by it. A closed list literal may not end in an ellipsis. The # of a closed list or struct literal must immediately precede the bracket. In a file with the experiment, #[ always starts a closed list literal: an index or slice on a definition named # is written (#)[i] or (#)[i:j].

@experiment(openlists)
 
a: #[{name: "x"}]
a: [{name: "x", port: 80}]    // the element is open
a: [{name: "x"}, {name: "y"}] // _|_: incompatible list lengths

ListLit       = [ "#" ] "[" [ ElementList [ "," ] ] "]" .
ElementList   = Ellipsis | Embedding { "," Embedding } [ "," Ellipsis ] .

List: *null | {
    Elem: _
    Tail: List
}

open: List & { Elem: 1, Tail: { Elem: 2 } }

closed: List & { Elem: 1, Tail: { Elem: 2, Tail: null } }