Implement some type literals

[apt1002]

At least

struct Foo(name1: type1, $name2: type2, ...)

union Foo (
    CASE1(type11, type12, ...),
    CASE2(type21, type22, ...),
    ...
)

array type

In Welly-in-Python, the syntax for union uses braces, not round brackets. However, the contents of the brackets certainly look like comma-separated expressions, so the brackets should be round.

[apt1002]

A possible alternative syntax for union types is

| CASE1(type11, type12, ...)
| CASE2(type21, type22, ...)

This is a little harder to parse. It requires | to be a prefix operator and an infix operator.

This syntax for union types would be ergonomic in function return types:

fn parse(...): | OK(Tree) | ERR(String) { ... }

Ideally, the infix | operator should also form the union of existing union types, as in the following examples:

Foo = | FOO()
Bar = | BAR()
FooBaz = Foo | BAZ()
BazBar = | BAZ() | Foo

fn handle(
    ...
):
    | OK(Response)
    | HttpError
    | IOError
{
    ...
}

But maybe it's better to make a larger syntactic distinction between FOO() (a value) and | FOO() (its type).

[apt1002]

Better syntax:

• The syntax for a union type containing only FOO(x, y) for x: T and y: U is FOO[T, U].
• | is not a prefix operator. As an infix operator it computes type union.
• The syntax for the tuple type containing (x, y) for x: T and y: U is [T, U].

The examples then look like this:

fn parse(...): OK[Tree] | ERR(String) { ... }

Foo = FOO[];
Bar = BAR[];
FooBaz = Foo | BAZ[]
BazBar = BAZ[] | Bar

fn handle(
    ...
):
    OK[Response] |
    HttpError |
    IOError
{
    ...
}