120 Pages

This is an alternative to the Tuples_and_Arrays proposal, though they share some ideas and features.

A sequence is an ordered list of items. Sequences are flat: they do not nest. A sequences with a single item is the same as that item.

Comma is a binary operator for constructing sequences:

`1,2` ==> a sequence with two values
`1,2,3` ==> a sequence with 3 values

Comma is associative:

`1,2,3` is the same as `(1,2),3` or `1,(2,3)`

The zero-item sequence is written: `()`. The zero-item sequence is the same as the "void value". Parens are just grouping: `((x))` is the same as `(x)` which is the same as `x` if `x` is a "primary",

Sequences are first-class: The value of a variable, attribute, expression, etc is sequence, with 0, 1, or many items.

A function parameter list is a sequence:

``` function f(x, y) { "x is {x} and y is {y}" }
let a = (2,3);
f(a) ==>  "x is 2 and y is 3"
```

So how can we assign a non-singleton sequence to a function parameter? The answer: Pattern matching:

``` function f(x : int, y : int, rest: int*)
{ "x is {x} and y is {y} and rest is {rest}" }
f(2,3,4,5) ==> "x is 2 and y is 3 and rest is (4,5)"
```

Basically the formal parameter list is a kind of regular expression that is matched against the actual parameter tuple.

(See Patterns for more on pattern matching, but note that page assumes the Tuples_and_Arrays, and so it doesn't need general "regular-expression"-matching.)

If a formal parameter is a simple name, the default type is "any single item", so it only matches one item.

But using pattern matching to extract sub-sequences from a parameter list is awkward. We need some way of more directly grouping some values with a specific parameter, which is difficult without nesting. But we can replace direct nesting by indirect nesting, by wrapping an inner sequence in an object.

Another way to handle multiple sequence-valued parameters is by using keyword parameters:

``` Person(name: "John", sons: ("Ed", "John jr"), daughters: "Betty")
```

This returns a Person object, passing in a sequence of 2 sons, and a different sequence of 1 daughter. This could be defined:

``` function Person(name: n, sons: s default (), daughters: d default ())
{ ... }
```

Note this latter is actually a special case of wrapping an inner sequence in an object, because a keyword parameter:

``` name: value
```

is equivalent to:

``` MapEntry("name", value)
```

which leads to the relationship between sequences, maps, and objects, which is another discussion.

Back to OpenJFX Compiler.

Community content is available under CC-BY-SA unless otherwise noted.