Compound Types and Values
Grammar
type ::= qualname
| array_type
| tuple_type
| record_type
| sum_type
| function_type
| type_application
| existential_size
tuple_type ::= "(" ")" | "(" type ("," type)+ [","] ")"
array_type ::= "[" [exp] "]" type
sum_type ::= constructor type* ("|" constructor type*)*
record_type ::= "{" "}" | "{" fieldid ":" type ("," fieldid ":" type)* [","] "}"
type_application ::= type type_arg | "*" type
type_arg ::= "[" [dim] "]" | type
function_type ::= param_type "->" type
param_type ::= type | "(" name ":" type ")"
stringlit ::= '"' stringchar* '"'
stringchar ::= <any source character except "\" or newline or double quotes>
charlit ::= "'" char "'"
char ::= <any source character except "\" or newline or single quotes>
existential_size ::= "?" ("[" name "]")+ "." type
Description
Compound types can be constructed based on the primitive types. The Wyn type system is entirely structural, and type abbreviations are merely shorthands. The only exception is abstract types whose definition has been hidden via the module system.
Tuple Types
A tuple value or type is written as a sequence of comma-separated values or types enclosed in parentheses. For example, (0, 1) is a tuple value of type (i32, i32). The elements of a tuple need not have the same type – the value (false, 1, 2.0) is of type (bool, i32, f64). A tuple element can also be another tuple, as in ((1,2),(3,4)), which is of type ((i32, i32), (i32, i32)). A tuple cannot have just one element, but empty tuples are permitted, although they are not very useful. Empty tuples are written () and are of type ().
Array Types
An array value is written as a sequence of zero or more comma-separated values enclosed in square brackets: [1, 2, 3]. An array type is written as [d]t, where t is the element type of the array, and d is an expression of type i64 indicating the number of elements in the array. We can elide d and write just [] (an anonymous size), in which case the size will be inferred.
As an example, an array of three integers could be written as [1, 2, 3], and has type [3]i32. An empty array is written as [], and its type is inferred from its use. When writing Wyn values for testing purposes, empty arrays are written empty([0]t) for an empty array of type [0]t.
Multi-dimensional arrays are supported in Wyn, but they must be regular, meaning that all inner arrays must have the same shape. For example, [[1,2], [3,4], [5,6]] is a valid array of type [3][2]i32, but [[1,2], [3,4,5], [6,7]] is not, because we cannot come up with integers m and n such that [m][n]i32 describes the array. The restriction to regular arrays is rooted in low-level concerns about efficient compilation.
Sum Types
Sum types are anonymous in Wyn, and are written as the constructors separated by vertical bars. Each constructor consists of a #-prefixed name, followed by zero or more types, called its payload.
Note: The current implementation of sum types is fairly inefficient, in that all possible constructors of a sum-typed value will be resident in memory. Avoid using sum types where multiple constructors have large payloads.
Record Types
Records are mappings from field names to values, with the field names known statically. A tuple behaves in all respects like a record with numeric field names starting from zero, and vice versa. It is an error for a record type to name the same field twice. A trailing comma is permitted.
Function Types
Functions are classified via function types, but they are not fully first class. See Higher-order functions for the details.
String and Character Literals
Wyn has no first-class strings or character type. A string literal
("...") is a lexical token accepted only in two non-expression
positions: the path in import "..." and the linkage name in
#[linked("...")]. Writing a string where a value is expected is a
syntax error.
Existential Size Quantifiers
An existential size quantifier brings an unknown size into scope within a type. This can be used to encode constraints for statically unknown array sizes.