Files
rexlang/docs/11-cheatsheet.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

137 lines
4.3 KiB
Markdown

# 11. Cheatsheet
## Basics
```rex
var x = 1 // changeable; type inferred
var y: float = 2 // with a type
const MAX = 100 // fixed
x += 1 // also -= *= /= %=
print("x is {x}", y) // interpolation with { }
```
## Types
`int float bool char string error` · sized: `i8 i16 i32 u8 u16 u32 u64 f32` · `[]T` list ·
`map[K, V]` map · `T?` optional · `shared T` · `weak T` · `func(A, B): R` function.
Convert numbers with `float(x)`, `int(x)`, `u8(x)`.
## Control flow
```rex
if a > b { } else if a == b { } else { }
for i in 0..10 { } // 0..9
for i in 0..10 step 2 { }
for x in list { }
for i, x in list { }
for k, v in map { }
for cond { }
for { break }
match v { 1 => a, _ => b }
```
## Functions
```rex
func add(a, b: int): int { return a + b }
func f(): (int, error) { return 1, nil }
var n, err = f()
var n = f()? // inside a function that returns error
var g = func(x: int): int { return x * 2 }
var h = x => x * 2 // where the type is known
```
## Lists
```rex
var xs = [1, 2, 3] var e: []int
xs.push(4) xs.pop() xs.len()
xs[0] xs[0] = 9 xs[1..3]
```
## Maps
```rex
var m = {"a": 1} var e: map[string, int] = {}
var e2 = map[string, int]{}
m["b"] = 2 // add or replace
m["b"] += 1 // missing key counts as zero
m["a"] // value; stops if missing
m.has("a") m.get("a") // bool, value-or-nil
m.get_or("z", 0) m.len() m.keys() m.values() m.remove("a")
```
## Strings
```rex
s.len() s.upper() s.lower() s.trim() s.split(",") s.lines() s.fields()
s.replace(a, b) s.repeat(n) s.contains(x) s.starts_with(x) s.ends_with(x)
s.index_of(x) s.to_int() s.to_float() s[1..4] s[2..] s[..3]
["a", "b"].join("-")
```
## Characters
```rex
var c = 'a' '\n' 'é' // one character, single quotes
c == 'a' c < 'z' // compare
c.is_digit() c.is_letter() c.is_alnum() c.is_space() c.is_upper() c.is_lower()
c.upper() c.lower()
int(c) char(97) string(c) "{c}" // number <-> char, char -> text
for c in s { } for i, c in s { } // walk a string; i = byte position
s[i] // the char starting at byte i
```
## Structs and enums
```rex
struct P {
name: string
x, y: float
func move(dx: float) { x += dx } // mutation is inferred
}
var p = P{name: "a"} // or positional: P{"a", 0.0, 0.0}
enum E {
A
B(n: int)
}
E.B(3) match e { A => 1, B(n) => n }
```
## Errors and nil
```rex
error("message {x}") err != nil return 0, nil
var v: int? = nil if v != nil { v } if v == nil { return }
```
## Sharing
```rex
var a = shared T{...} var b = a // same value, two owners
var w = weak a w.upgrade() // shared T? (nil if gone)
```
## Generics and interfaces
```rex
func first[T](xs: []T): T { return xs[0] }
func big[T: Ordered](a, b: T): T { ... } // Ordered, Number, or an interface
struct Stack[T] { items: []T } Stack[int]{}
interface Shape { area(): float } // follow it by having the methods
var s: Shape = Circle{1.0}
```
## Files
```rex
import utils // utils.rex next to this file
import tools.fs // tools/fs.rex, used as fs.name
import os // built-in: os math time
pub func f() {} // visible to other files
```
## C libraries
```rex
import "zlib.h" // zlib.crc32(...), zlib.Z_OK, types like zlib.gzFile
import "raylib.h" { InitWindow } // only these names, used bare
import "foo.h" link "foo" // when pkg-config doesn't know it (libfoo.so)
var f = stdio.fopen("x.txt", "r") // C pointers: compare with nil, close them yourself
lib.fill(buf, n) // T* parameters take a variable or a list
```
## Commands
`rex run f.rex args…` · `rex build f.rex -o out` · `rex check f.rex` · `rex emit-c f.rex` · `rex fmt path` (`--check` to only report) · `rex lsp` (editor server) · `rex header x.h [word]` (what a C header offers)
## Things that stop the program (exit code 2)
Divide by zero · list index/slice out of range · `pop` on an empty list · reading a missing
map key with `m[k]` · using a `nil` or gone `weak` value · calling a `nil` function or interface.