Files
rexlang/docs/09-generics-and-interfaces.md
T
Your NameandClaude Opus 5.5 7cf9727bcd Rename the language from Dino to Rex
Files use .rex, the command is rex, and the crate, runtime prefixes,
docs, editor files and examples all use the new name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 13:51:23 +01:00

185 lines
3.5 KiB
Markdown

# 9. Generics and interfaces
## Generic functions
Put the type names in `[ ]` after the function name. The compiler works the real types out
from the arguments.
```rex
func first[T](xs: []T): T {
return xs[0]
}
func biggest[T: Ordered](a, b: T): T {
if a > b { return a }
return b
}
func main() {
print(first([7, 8, 9]), first(["x", "y"]))
print(biggest(3, 9), biggest("pear", "apple"), biggest(1.5, 0.5))
}
```
```text
7 x
9 pear 1.5
```
After the colon you can name a **rule** for the type:
| Rule | Meaning |
|------|---------|
| `Ordered` | can be compared with `<` `>` (numbers and strings) |
| `Number` | numbers only |
| an interface | has certain methods (see below) |
| *(none)* | anything |
Generics cost nothing at run time: every set of types gets its own compiled copy.
A generic function can take functions too, which makes `map` and `filter` easy to write:
```rex
func map[T, U](xs: []T, f: func(T): U): []U {
var out: []U
for x in xs { out.push(f(x)) }
return out
}
func main() {
print(map([1, 2, 3], x => x * 10))
print(map(["a", "bb"], s => s.len()))
}
```
```text
[10, 20, 30]
[1, 2]
```
## Generic types
Structs and enums can take types too. When you **use** one, write the types out.
```rex
struct Stack[T] {
items: []T
func push_item(x: T) { items.push(x) }
func pop_item(): T { return items.pop() }
func size(): int { return items.len() }
}
enum Maybe[T] {
Some(value: T)
None
}
func main() {
var s = Stack[int]{}
s.push_item(1)
s.push_item(2)
print(s.pop_item(), s.size())
var m = Maybe[string].Some("hi")
print(m)
}
```
```text
2 1
Maybe[string].Some(hi)
```
## Interfaces
An interface lists methods. A type follows it just by having those methods, with no
`implements` keyword.
```rex
interface Shape {
area(): float
name(): string
}
struct Square {
side: float
func area(): float { return side * side }
func name(): string { return "square" }
}
struct Circle {
r: float
func area(): float { return 3.0 * r * r }
func name(): string { return "circle" }
}
```
### As a rule for generics
```rex
interface Shape {
area(): float
}
struct Square {
side: float
func area(): float { return side * side }
}
func report[T: Shape](s: T) {
print("area is", s.area())
}
func main() {
report(Square{3.0})
}
```
```text
area is 9.0
```
### As a type (dynamic dispatch)
An interface is also a type of its own. A variable of that type can hold any value that has
the methods, and the right method runs at run time. This is how you build a mixed list.
```rex
interface Shape {
area(): float
name(): string
}
struct Square {
side: float
func area(): float { return side * side }
func name(): string { return "square" }
}
struct Circle {
r: float
func area(): float { return 3.0 * r * r }
func name(): string { return "circle" }
}
func main() {
var shapes: []Shape = [Square{2.0}, Circle{1.0}]
for s in shapes {
print(s.name(), s.area())
}
var one: Shape = Circle{2.0}
print(one.area())
}
```
```text
square 4.0
circle 3.0
12.0
```
Details:
- A struct or enum value converts to the interface automatically. The value is copied in.
- `nil` is the empty interface value; calling a method on it stops the program.
- Not yet: turning an interface value back into its original type, and interfaces that take
their own type parameters.
Next: [Files and the standard library](10-modules-and-stdlib.md)