Compiler in Rust (lexer, parser, checker, C codegen), maps, chars, dino fmt, dino lsp (diagnostics, formatting, outline, definition, hover, completion, signature help), docs, examples, VS Code/Vim files. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
3.8 KiB
3.8 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.dino next to this file
import tools.fs // tools/fs.dino, used as fs.name
import os // built-in: os math time
pub func f() {} // visible to other files
Commands
dino run f.dino args… · dino build f.dino -o out · dino check f.dino · dino emit-c f.dino · dino fmt path (--check to only report) · dino lsp (editor server)
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.