# 1.1 Reference.

See List standard library code.

# 1.2 List constructors.

```  //Check List::_ctor_list
begin
fun str (x:list[int]) =>
match x with
| #Empty => "()"
| Cons (h, t) => "(" + (str h) + ", " + (str t) + ")"
endmatch
;
print\$ str\$ list[int](); endl;
print\$ str\$ list(4); endl;
print\$ str\$ list(4, 5); endl;
print\$ str\$ list(4, 5, 6); endl;
print\$ str\$ list(4, 5, 6, 7); endl;
end
```

```()
(4, ())
(4, (5, ()))
(4, (5, (6, ())))
(4, (5, (6, (7, ()))))
```

# 1.3 List length `len`.

```  //Check List::len
begin
print\$ len\$ list[int](); endl;
print\$ len\$ list(2); endl;
print\$ len\$ list(3, 4); endl;
print\$ len\$ list(5, 6, 7); endl;
print\$ len\$ list(8, 9, 10, 11); endl;
end
```

```0
1
2
3
4
```

# 1.4 List HOF iterator `iter`.

```  //Check List::iter
begin
val f = proc (i:int) { print i; };
iter f\$ list[int](); endl;
iter f\$ list(4); endl;
iter f\$ list(4, 5); endl;
iter f\$ list(4, 5, 6); endl;
iter f\$ list(4, 5, 6, 7); endl;
end
```

```4
45
456
4567
```

# 1.5 List `map`.

```  //Check List::map
begin
val f = proc (i:int) { print i; };
val g = fun (i:int) => i - 1;
iter f\$ map g\$ list[int](); endl;
iter f\$ map g\$ list(4); endl;
iter f\$ map g\$ list(4, 5); endl;
iter f\$ map g\$ list(4, 5, 6); endl;
iter f\$ map g\$ list(4, 5, 6, 7); endl;
end
```

```3
34
345
3456
```

# 1.6 List `fold_left`.

```  //Check List::fold_left
begin
val f = fun (x:int) (y:int) => x - y;
print\$ fold_left f 3\$ list[int](); endl;
print\$ fold_left f 3\$ list(4); endl;
print\$ fold_left f 3\$ list(4, 5); endl;
print\$ fold_left f 3\$ list(4, 5, 6); endl;
print\$ fold_left f 3\$ list(4, 5, 6, 7); endl;
end
```

```3
-1
-6
-12
-19
```

# 1.7 List `fold_right`.

```  //Check List::fold_right
begin
val f = fun (x:int) (y:int) => x + y;
print\$ fold_right f (list[int]()) 4; endl;
print\$ fold_right f (list(4)) 5; endl;
print\$ fold_right f (list(4, 5)) 6; endl;
print\$ fold_right f (list(4, 5, 6)) 7; endl;
print\$ fold_right f (list(4, 5, 6, 7)) 8; endl;
end
```

```4
9
15
22
30
```

# 1.8 List reverse `rev`.

```  //Check List::rev
begin
val f = proc (i:int) { print i; };
iter f\$ rev\$ list[int](); endl;
iter f\$ rev\$ list(4); endl;
iter f\$ rev\$ list(4, 5); endl;
iter f\$ rev\$ list(4, 5, 6); endl;
iter f\$ rev\$ list(4, 5, 6, 7); endl;
end
```

```4
54
654
7654
```