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

4.3 KiB

11. Cheatsheet

Basics

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

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

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

var xs = [1, 2, 3]            var e: []int
xs.push(4)   xs.pop()   xs.len()
xs[0]   xs[0] = 9   xs[1..3]

Maps

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

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

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

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

error("message {x}")          err != nil          return 0, nil
var v: int? = nil             if v != nil { v }   if v == nil { return }

Sharing

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

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

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

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.