Castile
=======
This is a test suite for Castile, written in [Falderal][] format.
While it cannot serve as a complete specification, it comes as
close as anything currently does to a specification for Castile.
[Falderal]: https://catseye.tc/node/Falderal
-> Tests for functionality "Run Castile Program"
### Rudiments ###
Minimal correct program.
| fun main() {}
=
A program may evaluate to a value.
| fun main() { 160 }
= 160
The function named `main` is the one that is evaluated when the
program is run.
| fun foobar(a, b, c) { 100 }
| fun main() { 120 }
| fun f() { 140 }
= 120
`main` should have no formal arguments.
| fun main(a, b, c) {
| 120
| }
? type mismatch
But other functions may.
| fun foobar(a, b) { b }
| fun main() { foobar(100, 200) }
= 200
Defined function names must be unique.
| fun dup() { 1 }
| fun dup() { 2 }
? duplicate
Formal argument names must be unique.
| fun f(g, g) {}
| fun main() { 1 }
? defined
Functions must be defined before they are referenced.
| fun main() { f(7) }
| fun f(g) { g }
? undefined
Either that, or forward-declared.
| f : integer -> integer
| fun main() { f(7) }
| fun f(g) { g * 2 }
= 14
If forward-declared, types must match.
| f : integer -> string
| fun main() { f(7) }
| fun f(g) { g * 2 }
? type mismatch
Arguments must match...
| fun f(g, h) { g * 2 + h * 2 }
| fun main() { f(7) }
? argument mismatch
| fun f(g, h) { g * 2 + h * 2 }
| fun main() { f(7,8,9) }
? argument mismatch
### Statements ###
Statements are commands that have the type void and are executed for their
side-effects. So, in general, statements may not be expressions. The
exception is that the last statement in a block may be an expression; the
result of that expression is the value of the block.
| fun main() {
| 20 * 8
| }
= 160
| fun main() {
| 20 + 3 * 8;
| 20 * 8
| }
? type mismatch
An `if`/`else` lets you make decisions.
| fun main() {
| a = 0;
| if 3 > 2 {
| a = 70
| } else {
| a = 80
| }
| a
| }
= 70
An `if` need not have an `else`.
| fun main() {
| a = 60
| if 3 > 2 {
| a = 70
| }
| a
| }
= 70
`if` always typechecks to void, one branch or two.
| fun main() {
| a = 60
| if 3 > 2 {
| a = 70
| }
| }
=
| fun main() {
| a = 60
| if 3 > 2 {
| a = 70
| } else {
| a = 90
| }
| }
=
If an `if` does have an `else`, the part after `else` must be either a block
(already shown) or another `if`.
| fun main() {
| if 2 > 3 {
| return 60
| } else if 4 > 5 {
| return 0
| } else {
| return 1
| }
| }
= 1
No dangling else problem.
| fun main() {
| if 2 > 3 {
| return 60
| } else if 4 < 5 {
| return 99
| } else {
| return 1
| }
| }
= 99
`while` loops.
| fun main() {
| a = 0 b = 4
| while b > 0 {
| a = a + b
| b = b - 1
| }
| a
| }
= 10
A `while` itself has void type.
| fun main() {
| a = 0; b = 4;
| while b > 0 {
| a = a + b;
| b = b - 1;
| }
| }
=
`break` may be used to prematurely exit a `while`.
| fun main() {
| a = 0; b = 0;
| while true {
| a = a + b;
| b = b + 1;
| if (b > 4) { break; }
| }
| a
| }
= 10
### Expressions ###
Precedence.
| fun main() {
| 2 + 3 * 4 /* not 20 */
| }
= 14
Unary negation.
| fun main() {
| -3
| }
= -3
| fun main() {
| 2+-5
| }
= -3
Minus sign must be right in front of a number.
| fun main() {
| -(4)
| }
? Expected
Unary not.
| fun main() {
| not (4 > 3)
| }
= False
Precedence of unary not.
| fun main() {
| not true or true
| }
= True
| fun main() {
| not 3 > 4
| }
= True
### Local Variables ###
Local variables.
| fun main() {
| a = 6;
| b = 7;
| a + b
| }
= 13
Local variables can be assigned functions.
| fun ancillary(x) { x * 2 }
| fun main() {
| a = ancillary;
| a(7)
| }
= 14
Local variables can be assigned.
| fun main() {
| a = 6;
| a = a + 12;
| a
| }
= 18
| fun main() {
| a = 6;
| z = 99;
| a
| }
= 6
| fun main() {
| z = 6;
| a
| }
? undefined
Local variables cannot occur in expressions until they are defined by an
initial assignment.
| fun main() {
| z = a * 10;
| a = 10;
| z
| }
? undefined
A local variables may not be defined inside an `if` or `while` or `typecase`
block, as it might not be executed.
| fun main() {
| if (4 > 5) {
| a = 10;
| } else {
| b = 11;
| }
| b
| }
? within control
| fun main() {
| b = false;
| while b {
| a = 10;
| }
| a
| }
? within control
| fun main() {
| a = 55 as integer|string;
| typecase a is string {
| b = 7
| }
| a
| }
? within control
Assignment, though it syntactically may occur in expressions, has a type of
void, so it can only really happen at the statement level.
| fun main() {
| a = 0; b = 0;
| a = b = 9;
| }
? type mismatch
Variables in upper scopes may be modified.
| fun main() {
| a = 0
| if 3 > 2 {
| a = 4;
| }
| a
| }
= 4
### Non-local Values ###
Literals may appear at the toplevel. Semicolons are optional at toplevel.
| factor = 5;
| fun main() {
| 6 * factor
| }
= 30
Toplevel literals may not be updated. Thus, the following looks like it
is defining a local with the same name as a toplevel, which is not permitted.
| factor = 5
| fun main() {
| factor = 7
| }
? shadows
Toplevel literals may be function literals (the syntax we've been using is just sugar.)
| main = fun() {
| 7
| }
= 7
Truth and falsehood are builtin toplevels.
| fun main() {
| true or false
| }
= True
| fun main() {
| false and true
| }
= False
So is `null`, which is the single value of `void` type.
| fun wat(x: void) { 3 }
| fun main() {
| wat(null)
| }
= 3
### More on Functions ###
Function arguments may not be updated.
| fun foo(x) {
| x = x + 14;
| x
| }
| fun main() {
| foo(7)
| }
? shadows
Factorial can be computed.
| factorial : integer -> integer
| fun factorial(a) {
| if a == 0 {
| return 1
| } else {
| return a * factorial(a - 1)
| }
| }
| fun main() {
| factorial(6)
| }
= 720
Literal functions.
| fun main() {
| inc = fun(x) { x + 1 };
| inc(7)
| }
= 8
| fun main() {
| fun(x){ x + 1 }(9)
| }
= 10
| fun main() {
| a = 99;
| a = fun(x){ x + 1 }(9);
| a
| }
= 10
Literal functions can have local variables, loops, etc.
| fun main() {
| z = 99;
| z = fun(x) {
| a = x; b = x;
| while a > 0 {
| b = b + a; a = a - 1;
| }
| return b
| }(9);
| z
| }
= 54
Literal functions can define other literal functions...
| fun main() {
| fun(x){ fun(y){ fun(z){ z + 1 } } }(4)(4)(10)
| }
= 11
Literal functions can access globals.
| oid = 19
| fun main() {
| fun(x){ x + oid }(11);
| }
= 30
Literal functions cannot access variables declared in enclosing scopes.
| fun main() {
| oid = 19;
| fun(x){ x + oid }(11);
| }
? undefined
Literal functions cannot access arguments declared in enclosing scopes.
| fun main() {
| fun(x){ fun(y){ fun(z){ y + 1 } } }(4)(4)(10)
| }
? undefined
Functions can be passed to functions and returned from functions.
| fun doubble(x) { x * 2 }
| fun triple(x) { x * 3 }
| fun apply_and_add_one(f: (integer -> integer), x) { f(x) + 1 }
| fun sellect(a) { if a > 10 { return doubble } else { return triple } }
| fun main() {
| t = sellect(5);
| d = sellect(15);
| p = t(10);
| apply_and_add_one(d, p)
| }
= 61
To overcome the syntactic ambiguity with commas, function types
in function definitions must be in parens.
| fun add(x, y) { x + y }
| fun mul(x, y) { x * y }
| fun do_it(f: (integer, integer -> integer), g) {
| f(3, g)
| }
| fun main() {
| do_it(mul, 4) - do_it(add, 4)
| }
= 5
`return` may be used to prematurely return a value from a function.
| fun foo(y) {
| x = y
| while x > 0 {
| if x < 5 {
| return x;
| }
| x = x - 1;
| }
| 17
| }
| fun main() {
| foo(10) + foo(0)
| }
= 21
Type of value returned must jibe with value of function's block.
| fun foo(x) {
| return "string";
| 17
| }
| fun main() {
| foo(10) + foo(0)
| }
? type mismatch
Type of value returned must jibe with other return statements.
| fun foo(x) {
| if x > 0 {
| return "string";
| } else {
| return 17
| }
| }
| fun main() {
| foo(10) + foo(0)
| }
? type mismatch
### Equality ###
Equality, inequality, boolean operators.
| fun main() {
| if 15 == 15 and ((15 != 14) or false) {
| print("struth")
| }
| }
= struth
| fun main() {
| if "five" == "five" and (("six" != "seven") or false) {
| print("struth")
| }
| }
= struth
Equality cannot be checked between two values of different types.
| fun main() {
| if 15 == "fifteen" {
| print("wat")
| }
| }
? mismatch
| fun main() {
| if 15 != "fifteen" {
| print("wat")
| }
| }
? mismatch
Equality can be checked between unions, as long as they are
unions entirely of simple (non-struct) types.
| fun main() {
| a = 40 as string|integer
| b = 40 as string|integer
| if a == b {
| print("it is")
| }
| }
= it is
| fun main() {
| a = 40 as string|integer
| b = "beep" as string|integer
| if a != b {
| print("correct")
| }
| }
= correct
Equality cannot be tested between two disjoint unions.
| fun main() {
| a = 40 as string|integer
| b = 40 as integer|void
| if a == b {
| print("correct")
| }
| }
? mismatch
Equality cannot be tested between values of a union type
that contains a struct type as one of its members.
| struct person { name: string; age: integer }
| fun main() {
| a = 40 as person|integer
| b = 40 as person|integer
| if a == b {
| print("it is")
| }
| }
? struct
### Builtins ###
The usual.
| fun main() {
| print("Hello, world!")
| }
= Hello, world!
Some standard functions are builtin and available as toplevels.
| fun main() {
| a = "hello";
| b = len(a);
| while b > 0 {
| print(a);
| b = b - 1;
| a = substr(a, 1, b)
| }
| }
= hello
= ello
= llo
= lo
= o
The `+` operator is not string concatenation. `concat` is.
| fun main() {
| print("hello " + "world")
| }
? type mismatch
| fun main() {
| print(concat("hello ", "world"))
| }
= hello world
The builtin toplevels are functions and functions need parens.
| fun main() {
| print "hi"
| }
? type mismatch
Note that the above was the motivation for requiring statements to have void
type; if non-void exprs could be used anywhere, that would just throw away
the function value `print` (b/c semicolons are optional) and return 'hi'.
### Struct Types ###
Record types. You can define them:
| struct person { name: string; age: integer }
| main = fun() {}
=
And make them.
| struct person { name: string; age: integer }
| main = fun() {
| j = make person(name:"Jake", age:23);
| print("ok")
| }
= ok
And extract the fields from them.
| struct person { name: string; age: integer }
| main = fun() {
| j = make person(name:"Jake", age:23);
| print(j.name)
| if j.age > 20 {
| print("Older than twenty")
| } else {
| print("Underage")
| }
| }
= Jake
= Older than twenty
Structs must be defined somewhere.
| main = fun() {
| j = make person(name:"Jake", age:23);
| j
| }
? undefined
Structs need not be defined before use.
| main = fun() {
| j = make person(name:"Jake", age:23);
| j.age
| }
| struct person { name: string; age: integer }
= 23
Structs may not contain structs which don't exist.
| struct person { name: string; age: foobar }
| main = fun() { 333 }
? undefined
Types must match when making a struct.
| struct person { name: string; age: integer }
| main = fun() {
| j = make person(name:"Jake", age:"Old enough to know better");
| j.age
| }
? type mismatch
| struct person { name: string; age: integer }
| main = fun() {
| j = make person(name:"Jake");
| j.age
| }
? argument mismatch
| struct person { name: string }
| main = fun() {
| j = make person(name:"Jake", age:23);
| j.age
| }
? argument mismatch
Order of field initialization when making a struct doesn't matter.
| struct person { name: string; age: integer }
| main = fun() {
| j = make person(age: 23, name:"Jake");
| j.age
| }
= 23
Structs cannot be tested for equality with the `==` or `!==`
operators.
| struct person { name: string; age: integer }
| main = fun() {
| j = make person(age: 23, name:"Jake");
| k = make person(name:"Jake", age: 23);
| j == k
| }
? structs cannot be compared
| struct person { age: integer; name: string }
| main = fun() {
| j = make person(age: 23, name:"Jake");
| k = make person(age: 21, name:"Jake");
| j != k
| }
? structs cannot be compared
Structs of two different types cannot be tested for equality.
| struct person { age: integer; name: string }
| struct individual { age: integer; name: string }
| main = fun() {
| j = make person(age: 23, name:"Jake");
| k = make individual(age: 23, name:"Jake");
| j == k
| }
? mismatch
If you really want to compare two structs for equality, you'll
have to write the equality predicate function yourself.
| struct person { name: string; age: integer }
| equ_person = fun(a: person, b: person) {
| a.age == b.age and a.name == b.name
| }
| main = fun() {
| j = make person(age: 23, name:"Jake");
| k = make person(name:"Jake", age: 23);
| equ_person(j, k)
| }
= True
Structs cannot be compared for ordering.
| struct person { age: integer; name: string }
| main = fun() {
| j = make person(age: 23, name:"Jake");
| k = make person(age: 21, name:"Jake");
| j > k
| }
? structs cannot be compared
Structs can be passed to functions.
| struct person { name: string; age: integer }
| fun wat(bouncer: person) { bouncer.age }
| main = fun() {
| j = make person(name:"Jake", age:23);
| wat(j)
| }
= 23
Structs have name equivalence, not structural.
| struct person { name: string; age: integer }
| struct city { name: string; population: integer }
| fun wat(hometown: city) { hometown }
| main = fun() {
| j = make person(name:"Jake", age:23);
| wat(j)
| }
? type mismatch
Struct fields must all be unique.
| struct person { name: string; name: string }
| main = fun() {
| j = make person(name:"Jake", name:"Smith");
| }
? defined
Values can be retrieved from structs.
| struct person { name: string; age: integer }
| fun age(bouncer: person) { bouncer.age }
| main = fun() {
| j = make person(name:"Jake", age:23);
| age(j)
| }
= 23
| struct person { name: string }
| fun age(bouncer: person) { bouncer.age }
| main = fun() {
| j = make person(name:"Jake");
| age(j)
| }
? undefined
Different structs may have the same field name in different positions.
| struct person { name: string; age: integer }
| struct city { population: integer; name: string }
| main = fun() {
| j = make person(name:"Jake", age:23);
| w = make city(population:600000, name:"Winnipeg");
| print(j.name)
| print(w.name)
| }
= Jake
= Winnipeg
Can't define the same struct multiple times.
| struct person { name: string; age: integer }
| struct person { name: string; age: string }
| fun main() { 333 }
? duplicate
Structs may refer to themselves.
| struct recursive {
| next: recursive;
| }
| fun main() { 333 }
= 333
| struct odd {
| next: even;
| }
| struct even {
| next: odd;
| }
| fun main() { 333 }
= 333
But you can't actually make one of these infinite structs.
| struct recursive {
| next: recursive;
| }
| fun main() { make recursive(next:make recursive(next:"nooo")) }
? type mismatch
### Union Types ###
Values of union type are created with the type promotion operator,
`as ...`. Type promotion has a very low precedence, and can be
applied to any expression.
The type after the `as` must be a union.
| fun main() {
| a = 20;
| b = 30;
| a + b as integer
| }
? bad cast
The type of the value being cast by the `as` must be one of the types in the union.
| fun main() {
| a = 20;
| b = 30;
| a + b as string|void
| }
? bad cast
The type after the `as` must be the type of the expression.
| fun main() {
| a = 20;
| b = 30;
| c = a + b as integer|string
| print("ok")
| }
= ok
Each of the individual types named in the union type must be unique.
| fun foo(a, b: integer|string) {
| print("ok")
| }
| fun main() {
| a = 20;
| b = 30;
| c = a + b as integer|integer|string
| foo(a, c)
| }
? bad union type
One can, vacuously, promote a union type to itself.
| fun main() {
| a = 20;
| b = 30;
| c = a + b as integer|string
| d = c as integer|string
| print("ok")
| }
= ok
One can promote a union type to another union type, so long as it is a superset.
| fun main() {
| a = 20;
| b = 30;
| c = a + b as integer|string
| d = c as integer|string|void
| print("ok")
| }
= ok
One cannot promote a union type to a union type that is not a superset.
| fun main() {
| a = 20;
| b = 30;
| c = a + b as integer|string
| d = c as integer|void
| print("ok")
| }
? bad cast
Values of union type can be passed to functions.
| fun foo(a, b: integer|string) {
| a + 1
| }
| main = fun() {
| a = 0;
| a = foo(a, 333 as integer|string);
| a = foo(a, "hiya" as integer|string);
| a
| }
= 2
Order of types in a union doesn't matter.
| fun foo(a, b: integer|string) {
| a + 1
| }
| main = fun() {
| a = 0;
| a = foo(a, 333 as integer|string);
| a = foo(a, "hiya" as string|integer);
| a
| }
= 2
Trivial use of `typecase`.
| main = fun() {
| a = 333 as integer|string;
| typecase a is integer {
| print("int")
| };
| }
= int
Inside a `typecase` the variable can be used as a value of
the determined type.
| main = fun() {
| a = 333 as integer|string;
| typecase a is integer {
| print(str(a))
| };
| typecase a is string {
| print(a)
| };
| }
= 333
The `typecase` construct can operate on the "right" type of a union.
| fun foo(a, b: integer|string) {
| r = a;
| typecase b is integer {
| r = r + b;
| };
| typecase b is string {
| r = r + len(b);
| };
| r
| }
| main = fun() {
| a = 0;
| a = foo(a, 333 as integer|string);
| a = foo(a, "hiya" as integer|string);
| a
| }
= 337
The expression in a `typecase` must be a variable.
| main = fun() {
| a = 333 as integer|string;
| typecase 333 is integer {
| print("what?")
| };
| }
? identifier
The expression in a `typecase` can be an argument to the function in
which the `typecase` occurs.
| fun wat(j: integer|string) {
| typecase j is integer {
| print("integer")
| };
| }
| main = fun() {
| wat(444 as integer|string)
| }
= integer
The expression in a `typecase` cannot effectively be a global, as globals
must be literals and there is no way (right now) to make a literal of union
type.
Inside a `typecase` the variable cannot be updated.
| main = fun() {
| a = 333 as integer|string;
| typecase a is integer {
| a = 700;
| };
| }
? cannot assign
The union can include void.
| main = fun() {
| j = null as void|integer;
| typecase j is void {
| print("nothing there")
| };
| }
= nothing there
### Struct Types + Union Types ###
Union types may be used to make fields of a struct "nullable", so that
you can in actuality create recursive, but finite, data structures.
| struct list {
| value: string;
| next: list|integer;
| }
| main = fun() {
| l = make list(
| value: "first",
| next: make list(
| value: "second",
| next:0 as list|integer
| ) as list|integer)
| s = l.next
| typecase s is list {
| print(s.value)
| }
| }
= second
You may want to use helper functions to hide this ugliness.
| struct list {
| value: string;
| next: list|void;
| }
|
| fun empty() {
| return null as list|void
| }
|
| fun cons(v: string, l: list|void) {
| make list(value:v, next:l) as list|void
| }
|
| fun nth(n, l: list|void) {
| u = l;
| v = u;
| k = n;
| while k > 1 {
| typecase u is void { break; }
| typecase u is list { v = u.next; }
| u = v;
| k = k - 1;
| }
| return u
| }
|
| main = fun() {
| l = cons("first", cons("second", cons("third", empty())));
| h = nth(2, l);
| typecase h is list { print(h.value); }
| }
= second
And in fact, you can restrict the union types to smaller sets to
better indicate the allowable types of the functions. For example,
`cons` always returns a list, so that should be its return type,
not `list|void`. Likewise, `nth` requires a list. In this way we
can implement some of the "Parse, don't Validate" approach.
| struct list {
| value: string;
| next: list|void;
| }
|
| fun cons(v: string, l: list) {
| make list(value:v, next:l as list|void)
| }
|
| fun singleton(v: string) {
| make list(value:v, next:null as list|void)
| }
|
| fun nth(n, l: list) {
| u = l as list|void;
| v = u;
| k = n;
| while k > 1 {
| typecase u is void { break; }
| typecase u is list { v = u.next; }
| u = v;
| k = k - 1;
| }
| return u
| }
|
| main = fun() {
| l = cons("first", cons("second", singleton("third")));
| h = nth(2, l);
| typecase h is list { print(h.value); }
| }
= second
Structs may be empty.
| struct red { }
| fun show(color: red) {
| print("hi")
| }
| main = fun() {
| show(make red());
| }
= hi
In combination with unions, this lets us create "typed enums".
| struct red { }
| struct green { }
| struct blue { }
| fun show(color: red|green|blue) {
| typecase color is red { print("red"); }
| typecase color is green { print("green"); }
| typecase color is blue { print("blue"); }
| }
| main = fun() {
| show(make red() as red|green|blue);
| show(make blue() as red|green|blue);
| }
= red
= blue
### Scoped Structs ###
When a `struct` is declared, it may be associated with a set of identifiers.
Functions with these global names are the only function definitions which
can `make` such a struct, or see that it has fields; to all other functions,
these operations will not be available. It is in this way that encapsulation
is accomplished.
| struct list {
| value: string;
| next: list|void;
| } for (cons, singleton, length)
|
| fun cons(v: string, l: list) {
| make list(value:v, next:l as list|void)
| }
|
| fun singleton(v: string) {
| make list(value:v, next:null as list|void)
| }
|
| length : list|void -> integer
| fun length(l: list|void) {
| typecase l is void { return 0 }
| typecase l is list { return 1 + length(l.next) }
| }
|
| fun main() {
| l = cons("first", cons("second", singleton("third")));
| print(str(length(l as list|void)));
| }
= 3
| struct list {
| value: string;
| next: list|void;
| } for (cons, singleton, length)
|
| fun cons(v: string, l: list) {
| make list(value:v, next:l as list|void)
| }
|
| fun singleton(v: string) {
| make list(value:v, next:null as list|void)
| }
|
| length : list|void -> integer
| fun length(l: list|void) {
| typecase l is void { return 0 }
| typecase l is list { return 1 + length(l.next) }
| }
|
| fun main() {
| l = make list(value:"first", next:null as list|void);
| print(str(length(l as list|void)));
| }
? make
| struct list {
| value: string;
| next: list|void;
| } for (cons, singleton, length)
|
| fun cons(v: string, l: list) {
| make list(value:v, next:l as list|void)
| }
|
| fun singleton(v: string) {
| make list(value:v, next:null as list|void)
| }
|
| fun main() {
| l = cons("first", cons("second", singleton("third")));
| print(l.value);
| }
? struct
One can use this facility to implement abstract data types.
| struct assoc {
| key: string;
| value: string;
| next: assoc|void;
| } for (singleton, update, lookup, remove)
|
| fun singleton(k: string, v: string) {
| make assoc(key:k, value:v, next:null as assoc|void)
| }
|
| fun update(k: string, v: string, a: assoc) {
| make assoc(key:k, value:v, next:a as assoc|void)
| }
|
| lookup : assoc, string -> string|void
| fun lookup(a: assoc, k: string) {
| if a.key == k {
| return a.value as string|void
| }
| n = a.next
| typecase n is void {
| return null as string|void
| }
| typecase n is assoc {
| return lookup(n, k)
| }
| }
|
| fun main() {
| a = update("1", "first", update("2", "second", singleton("3", "third")));
| r = lookup(a, "2");
| print("um");
| typecase r is void { print("NOT FOUND"); }
| typecase r is string { print(r); }
| print("ya");
| }
= um
= second
= ya
This program should work even with a redundant upcast in it.
| struct assoc {
| key: string;
| value: string;
| next: assoc|void;
| } for (singleton, update, lookup, remove)
|
| fun singleton(k: string, v: string) {
| make assoc(key:k, value:v, next:null as assoc|void)
| }
|
| fun update(k: string, v: string, a: assoc) {
| make assoc(key:k, value:v, next:a as assoc|void)
| }
|
| lookup : assoc, string -> string|void
| fun lookup(a: assoc, k: string) {
| if a.key == k {
| return a.value as string|void
| }
| n = a.next
| typecase n is void {
| return null as string|void
| }
| typecase n is assoc {
| return lookup(n, k) as string|void
| }
| }
|
| fun main() {
| a = update("1", "first", update("2", "second", singleton("3", "third")));
| r = lookup(a, "2");
| print("um");
| typecase r is void { print("NOT FOUND"); }
| typecase r is string { print(r); }
| print("ya");
| }
= um
= second
= ya