Dino compiler: language, formatter, language server, docs, editor support

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>
This commit is contained in:
Your NameandClaude Sonnet 5.5 committed 2026-11-07 23:46:12 +01:00
1 parent 3e2779f447
commit eaf9567a36
117 files changed
+19970

No files matched your search

+29
View File
@@ -0,0 +1,29 @@
// A small CLI tool: count lines and words in files.
import os
struct Stats {
lines: int
words: int
}
func count(path: string): (Stats, error) {
var text = os.read_file(path)? // ? returns the error to the caller
var stats = Stats{}
for line in text.lines() {
stats.lines += 1
stats.words += line.fields().len()
}
return stats, nil
}
func main() {
var args = os.args
for path in args[1..] {
var s, err = count(path)
if err != nil {
print("{path}: error: {err}")
continue
}
print("{path}: {s.lines} lines, {s.words} words")
}
}
+33
View File
@@ -0,0 +1,33 @@
// A game: bouncing square. Structs are values, no heap, no GC.
import gfx
struct Vec2 {
x, y: f32
func add(b: Vec2): Vec2 { return Vec2{x + b.x, y + b.y} }
func scale(k: f32): Vec2 { return Vec2{x * k, y * k} }
}
struct Player {
pos: Vec2
vel: Vec2
size: f32
func update(dt: f32) { // writes pos/vel: inferred as mutating
pos = pos.add(vel.scale(dt))
if pos.x < 0 || pos.x > 800 { vel.x = -vel.x }
if pos.y < 0 || pos.y > 600 { vel.y = -vel.y }
}
}
func main() {
var win = gfx.open("Dino", 800, 600)
var player = Player{pos: Vec2{100, 100}, vel: Vec2{200, 150}, size: 32}
for win.is_open() {
player.update(win.dt())
win.clear(gfx.BLACK)
win.rect(player.pos.x, player.pos.y, player.size, player.size, gfx.GREEN)
win.present()
}
}
+32
View File
@@ -0,0 +1,32 @@
// A desktop-style app: shared state, weak back-references, tasks.
import ui
import task
struct Document {
title: string
text: string
}
struct Editor {
doc: shared Document // many views can share one document
parent: weak Window? // weak: no ownership cycle
}
func main() {
var doc = shared Document{title: "Notes", text: ""}
var win = ui.window("Dino Notes", 640, 480)
var editor = Editor{doc: doc}
win.on_key(func(k: ui.Key) {
editor.doc.text += k.char
})
var ch = task.channel[string]()
task.spawn(func() { // background autosave
for text in ch.recv() { save(text) }
})
win.on_close(func() { ch.send(doc.text) })
win.run()
}
+23
View File
@@ -0,0 +1,23 @@
// Enums with data, generics, interfaces.
enum Shape {
Circle(r: f64)
Rect(w, h: f64)
}
func area(s: Shape): f64 {
return match s {
Circle(r) => 3.14159 * r * r
Rect(w, h) => w * h
}
}
interface Drawable { draw() }
func draw_all[T: Drawable](items: []T) {
for item in items { item.draw() }
}
func max[T: Ordered](a, b: T): T {
if a > b { return a }
return b
}
+37
View File
@@ -0,0 +1,37 @@
struct Tok { first: char }
func kind(c: char): string {
return match c {
'+' => "plus"
'\n' => "newline"
' ' => "space"
_ => "other"
}
}
func main() {
var c = 'a'
print(c, c == 'a', c < 'b', int(c), char(66), string(c) + "!")
var s = "héllo wörld 42"
var letters = 0
var digits = 0
for ch in s {
if ch.is_letter() { letters += 1 }
if ch.is_digit() { digits += 1 }
}
print(letters, digits, s.len())
for i, ch in "aé😀" { print(i, ch) }
print(s[0], s[1], s[3], s[s.len() - 1])
var up = ""
for ch in "dino" { up += string(ch.upper()) }
print(up, 'Q'.lower(), kind('+'), kind('\n'), kind('z'))
var counts: map[char, int] = {}
for ch in "banana" { counts[ch] += 1 }
print(counts)
var w = ""
for ch in "a b c" {
if ch == ' ' { continue }
w += string(ch)
}
print(w, 'a'.is_alnum(), ' '.is_space(), 'A'.is_upper())
}
+9
View File
@@ -0,0 +1,9 @@
a true true 97 B a!
10 2 16
0 a
1 é
3 😀
h é l 2
DINO q plus newline other
{b: 1, a: 3, n: 2}
abc true true true
+74
View File
@@ -0,0 +1,74 @@
struct Button {
label: string
on_click: func(string)
clicks: int
func click() {
clicks += 1
on_click(label)
}
}
func apply(f: func(int): int, x: int): int {
return f(x)
}
func twice(f: func(int): int): func(int): int {
return func(x: int): int { return f(f(x)) }
}
func make_counter(): func(): int {
var n = 0
return func(): int {
n += 1
return n
}
}
func double(x: int): int { return x * 2 }
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 filter[T](xs: []T, keep: func(T): bool): []T {
var out: []T
for x in xs {
if keep(x) { out.push(x) }
}
return out
}
func main() {
var offset = 10
var add = func(x: int): int { return x + offset }
offset = 99 // the closure kept its own copy
print(add(1), apply(add, 5), apply(double, 4))
print(apply(x => x * x, 7), twice(double)(3), twice(x => x + 1)(0))
var next = make_counter()
var other = make_counter()
print(next(), next(), next(), other())
var snapshot = next // copies the closure, with its state
print(next(), snapshot())
var nums = [1, 2, 3, 4, 5, 6]
print(map(nums, x => x * 10))
print(map(nums, x => "n{x}"))
print(filter(nums, n => n % 2 == 0))
var total = 0
for n in nums { total += apply(double, n) }
print(total)
var log = ""
var b = Button{"OK", func(name: string) { print("clicked", name) }, 0}
b.click()
b.click()
print(b.clicks)
var handlers: []func(int): int
handlers.push(double)
handlers.push(x => x - 1)
for h in handlers { print(h(10)) }
}
+13
View File
@@ -0,0 +1,13 @@
11 15 8
49 12 2
1 2 3 1
4 4
[10, 20, 30, 40, 50, 60]
[n1, n2, n3, n4, n5, n6]
[2, 4, 6]
42
clicked OK
clicked OK
2
20
9
+101
View File
@@ -0,0 +1,101 @@
// A tree: a node holds a list of child trees (a list can hold the enum it is inside).
enum Tree {
Leaf(value: int)
Node(children: []Tree)
func sum(): int {
return match self {
Leaf(v) => v
Node(kids) => sum_all(kids)
}
}
func depth(): int {
return match self {
Leaf(_) => 1
Node(kids) => 1 + deepest(kids)
}
}
}
func sum_all(ts: []Tree): int {
var total = 0
for t in ts {
total += t.sum()
}
return total
}
func deepest(ts: []Tree): int {
var best = 0
for t in ts {
var d = t.depth()
if d > best {
best = d
}
}
return best
}
// Error handling with a plain enum.
enum Result {
Ok(value: int)
Err(msg: string)
}
func divide(a, b: int): Result {
if b == 0 {
return Result.Err("divide by zero")
}
return Result.Ok(a / b)
}
func show(r: Result) {
match r {
Ok(v) => print("ok:", v)
Err(m) => print("error:", m)
}
}
// Data inside an enum is a value like everything else.
enum Msg {
Quit
Say(text: string)
Batch(items: []string)
}
struct Inbox {
last: Msg
count: int
}
func main() {
var tree = Tree.Node([Tree.Leaf(1), Tree.Node([Tree.Leaf(2), Tree.Leaf(3)]), Tree.Leaf(4)])
print("sum", tree.sum(), "depth", tree.depth())
show(divide(10, 2))
show(divide(1, 0))
var m = Msg.Batch(["a", "b"])
var copy = m
match copy {
Batch(items) => {
items.push("c")
print("copy has", items)
}
_ => print("not a batch")
}
print("original still", m)
var inbox = Inbox{Msg.Say("hi"), 1}
var other = inbox
other.last = Msg.Quit
other.count += 1
print(inbox, other)
match inbox.last {
Say(t) => print("said", t)
Quit => print("quit")
Batch(_) => print("batch")
}
}
+7
View File
@@ -0,0 +1,7 @@
sum 10 depth 3
ok: 5
error: divide by zero
copy has [a, b, c]
original still Msg.Batch([a, b])
Inbox{last: Msg.Say(hi), count: 1} Inbox{last: Msg.Quit, count: 2}
said hi
+93
View File
@@ -0,0 +1,93 @@
enum Shape {
Circle(r: float)
Rect(w, h: float)
Point
func area(): float {
return match self {
Circle(r) => 3.14159 * r * r
Rect(w, h) => w * h
Point => 0
}
}
func name(): string {
return match self {
Circle(_) => "circle"
Rect(_, _) => "rectangle"
Point => "point"
}
}
}
enum Color {
Red
Green
Blue
}
func describe(c: Color): string {
return match c {
Color.Red => "warm"
Color.Green => "natural"
Color.Blue => "cool"
}
}
func classify(n: int): string {
return match n {
0 => "zero"
1 => "one"
_ => "many"
}
}
func main() {
var shapes = [Shape.Circle(1.5), Shape.Rect(2, 3), Shape.Point]
for s in shapes {
print(s.name(), s.area())
}
print(shapes)
var c = Color.Green
print(c, describe(c), c == Color.Green, c != Color.Blue)
for i in 0..4 {
print(i, classify(i))
}
// match as a statement can use blocks and loop control
var total = 0.0
for s in shapes {
match s {
Circle(r) => {
total += r
}
Rect(w, _) => {
if w > 100 {
break
}
total += w
}
_ => continue
}
print("so far", total)
}
// bool and string matches
var flag = true
print(match flag {
true => "yes"
false => "no"
})
var cmd = "stop"
match cmd {
"go" => print("going")
"stop" => print("stopping")
other => print("unknown:", other)
}
// the zero value of an enum is its first case
var z: Shape
print(z, Color.Red == (Color.Red))
}
+14
View File
@@ -0,0 +1,14 @@
circle 7.0685775
rectangle 6.0
point 0.0
[Shape.Circle(1.5), Shape.Rect(2.0, 3.0), Shape.Point]
Color.Green natural true true
0 zero
1 one
2 many
3 many
so far 1.5
so far 3.5
yes
stopping
Shape.Circle(0.0) true
+48
View File
@@ -0,0 +1,48 @@
func parse_digit(c: string): (int, error) {
if c == "0" { return 0, nil }
if c == "1" { return 1, nil }
if c == "2" { return 2, nil }
return error("not a digit: {c}")
}
func add_digits(a: string, b: string): (int, error) {
var x = parse_digit(a)?
var y = parse_digit(b)?
return x + y, nil
}
func check(n: int): error {
if n < 0 {
return error("negative: {n}")
}
return nil
}
func run(): error {
check(5)?
print("5 is fine")
check(-3)?
print("never printed")
return nil
}
func main(): error {
var sum, err = add_digits("1", "2")
if err != nil {
print("unexpected:", err)
} else {
print("sum =", sum)
}
var _, bad = add_digits("1", "x")
if bad != nil {
print("failed:", bad)
}
var ok: error = nil
print("ok is", ok)
run()?
print("not reached")
return nil
}
+4
View File
@@ -0,0 +1,4 @@
sum = 3
failed: not a digit: x
ok is nil
5 is fine
+12
View File
@@ -0,0 +1,12 @@
func fib(n: int): int {
if n < 2 {
return n
}
return fib(n - 1) + fib(n - 2)
}
func main() {
for i in 0..15 {
print("fib({i}) = {fib(i)}")
}
}
+15
View File
@@ -0,0 +1,15 @@
fib(0) = 0
fib(1) = 1
fib(2) = 1
fib(3) = 2
fib(4) = 3
fib(5) = 5
fib(6) = 8
fib(7) = 13
fib(8) = 21
fib(9) = 34
fib(10) = 55
fib(11) = 89
fib(12) = 144
fib(13) = 233
fib(14) = 377
+53
View File
@@ -0,0 +1,53 @@
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() }
func peek(): T { return items[items.len() - 1] }
}
enum Maybe[T] {
Some(value: T)
None
func or_else(fallback: T): T {
return match self {
Some(v) => v
None => fallback
}
}
}
struct Pair[A, B] {
first: A
second: B
}
struct Tree[T] {
value: T
kids: []Tree[T]
}
func find(xs: []int, x: int): Maybe[int] {
for v in xs {
if v == x { return Maybe[int].Some(v) }
}
return Maybe[int].None
}
func main() {
var s = Stack[int]{}
s.push_item(1)
s.push_item(2)
print(s.size(), s.peek(), s.pop_item(), s.size())
var names: Stack[string]
names.push_item("a")
names.push_item("b")
print(names.peek(), names)
print(find([1, 2, 3], 2).or_else(0), find([1], 9).or_else(-1))
var p = Pair[string, float]{"pi", 3.14}
print(p.first, p.second, p)
var t = Tree[int]{1, [Tree[int]{2, []}]}
print(t.kids.len(), t.kids[0].value)
}
+5
View File
@@ -0,0 +1,5 @@
2 2 2 1
b Stack[string]{items: [a, b]}
2 -1
pi 3.14 Pair[string, float]{first: pi, second: 3.14}
1 2
+3
View File
@@ -0,0 +1,3 @@
func main() {
print("Hello, Dino!")
}
+1
View File
@@ -0,0 +1 @@
Hello, Dino!
+79
View File
@@ -0,0 +1,79 @@
interface Shape {
area(): float
name(): string
scale(k: float)
}
struct Circle {
r: float
func area(): float { return 3.0 * r * r }
func name(): string { return "circle" }
func scale(k: float) { r = r * k }
}
struct Rect {
w, h: float
tag: string
func area(): float { return w * h }
func name(): string { return "rect " + tag }
func scale(k: float) {
w = w * k
h = h * k
}
}
enum Dot {
Small
Big
func area(): float { return 1.0 }
func name(): string { return "dot" }
func scale(k: float) {}
}
struct Scene {
shapes: []Shape
main_shape: Shape
}
func describe(s: Shape): string {
return "{s.name()}: {s.area()}"
}
func biggest(shapes: []Shape): Shape {
var best = shapes[0]
for s in shapes {
if s.area() > best.area() { best = s }
}
return best
}
func total[T: Shape](xs: []T): float {
var sum = 0.0
for x in xs { sum += x.area() }
return sum
}
func main() {
var shapes: []Shape = [Circle{1.0}, Rect{2.0, 3.0, "a"}, Dot.Big]
shapes.push(Circle{2.0})
for s in shapes { print(describe(s)) }
print(biggest(shapes).name())
// interface values are copies: changing one doesn't change the original
var c = Circle{1.0}
var s: Shape = c
s.scale(10.0)
print(c.r, s.area())
var t = s
t.scale(2.0)
print(s.area(), t.area())
var scene = Scene{shapes, Rect{1.0, 1.0, "main"}}
scene.main_shape.scale(3.0)
print(scene.main_shape.area(), scene.shapes.len())
print(scene.main_shape)
var none: Shape
print(none == nil, s == nil)
print(total(shapes))
}
+11
View File
@@ -0,0 +1,11 @@
circle: 3.0
rect a: 6.0
dot: 1.0
circle: 12.0
circle
1.0 300.0
300.0 1200.0
9.0 4
Rect{w: 3.0, h: 3.0, tag: main}
true false
22.0
+72
View File
@@ -0,0 +1,72 @@
interface Shape {
area(): float
name(): string
}
interface Resizable {
scale(k: float)
}
struct Circle {
r: float
func area(): float { return 3.0 * r * r }
func name(): string { return "circle" }
func scale(k: float) { r = r * k }
}
struct Rect {
w, h: float
func area(): float { return w * h }
func name(): string { return "rect" }
}
enum Dot {
Small
Big
func area(): float { return 1.0 }
func name(): string { return "dot" }
}
func describe[T: Shape](s: T): string {
return "{s.name()} with area {s.area()}"
}
func total_area[T: Shape](shapes: []T): float {
var sum = 0.0
for s in shapes { sum += s.area() }
return sum
}
func grow[T: Resizable](s: T): T {
var copy = s
copy.scale(2.0)
return copy
}
struct Gallery[T: Shape] {
items: []T
func add(x: T) { items.push(x) }
func biggest(): float {
var best = 0.0
for it in items {
if it.area() > best { best = it.area() }
}
return best
}
}
func main() {
print(describe(Circle{2.0}))
print(describe(Rect{2.0, 5.0}))
print(describe(Dot.Big))
print(total_area([Circle{1.0}, Circle{2.0}]))
print(grow(Circle{1.5}))
var g = Gallery[Rect]{}
g.add(Rect{1.0, 2.0})
g.add(Rect{3.0, 4.0})
print(g.biggest())
}
+6
View File
@@ -0,0 +1,6 @@
circle with area 12.0
rect with area 10.0
dot with area 1.0
15.0
Circle{r: 3.0}
12.0
+68
View File
@@ -0,0 +1,68 @@
// Lists are values: assigning or passing copies them.
struct Inventory {
items: []string
gold: int
func add(item: string) {
items.push(item)
}
func count(): int {
return items.len()
}
}
func add_one(xs: []int): []int {
xs.push(1)
return xs
}
func first(xs: []int): int {
return xs[0]
}
func main() {
var a = [1, 2, 3]
var b = a
b[0] = 99
b.push(4)
print(a, b)
// a function that changes its parameter works on its own copy
var c = add_one(a)
print(a, c)
print(first(a), first(c))
// structs holding lists copy deeply
var inv = Inventory{[], 10}
inv.add("sword")
var saved = inv
inv.add("shield")
saved.gold = 0
print(inv)
print(saved)
print(inv.count(), saved.count())
// nested lists
var grid = [[1, 2], [3, 4]]
var snapshot = grid
grid[0][1] = 20
grid[1].push(5)
print(grid)
print(snapshot)
// looping over a list while changing it walks the original
var xs = [1, 2, 3]
for x in xs {
xs.push(x * 10)
}
print(xs)
// the loop variable is a copy too
var ys = [1, 2, 3]
for y in ys {
y += 100
print(y)
}
print(ys)
}
+13
View File
@@ -0,0 +1,13 @@
[1, 2, 3] [99, 2, 3, 4]
[1, 2, 3] [1, 2, 3, 1]
1 1
Inventory{items: [sword, shield], gold: 10}
Inventory{items: [sword], gold: 0}
2 1
[[1, 20], [3, 4, 5]]
[[1, 2], [3, 4]]
[1, 2, 3, 10, 20, 30]
101
102
103
[1, 2, 3]
+60
View File
@@ -0,0 +1,60 @@
func sum(xs: []int): int {
var total = 0
for x in xs {
total += x
}
return total
}
func squares(n: int): []int {
var out: []int
for i in 0..n {
out.push(i * i)
}
return out
}
func largest(xs: []int): int {
var best = xs[0]
for x in xs {
if x > best {
best = x
}
}
return best
}
func main() {
var nums = [5, 3, 8, 1]
print(nums, nums.len())
print("sum:", sum(nums), "largest:", largest(nums))
nums.push(10)
nums[0] = 50
nums[1] += 7
print(nums)
print("popped", nums.pop(), "left", nums.len())
var sq = squares(6)
print(sq)
print(sq[1..4], sq[..2], sq[4..])
for i, x in sq {
if i % 2 == 0 {
print("sq[{i}] = {x}")
}
}
// an empty list needs a type
var empty: []string
print(empty, empty.len())
empty.push("a")
empty.push("b")
print(empty, "{empty.len()} items")
var floats: []float = [1, 2.5, 3]
print(floats)
var words = ["dino", "lang"]
print(words[0] + "-" + words[1], words[0].len())
}
+13
View File
@@ -0,0 +1,13 @@
[5, 3, 8, 1] 4
sum: 17 largest: 8
[50, 10, 8, 1, 10]
popped 10 left 4
[0, 1, 4, 9, 16, 25]
[1, 4, 9] [0, 1] [16, 25]
sq[0] = 0
sq[2] = 4
sq[4] = 16
[] 0
[a, b] 2 items
[1.0, 2.5, 3.0]
dino-lang 4
+51
View File
@@ -0,0 +1,51 @@
const LIMIT = 20
func is_prime(n: int): bool {
if n < 2 {
return false
}
var d = 2
for d * d <= n {
if n % d == 0 {
return false
}
d += 1
}
return true
}
func main() {
var sum = 0
for i in 1..11 {
sum += i
}
print("sum 1..10 =", sum)
print("evens:")
for i in 0..LIMIT step 2 {
print(i)
}
print("countdown:")
for i in 5..0 step -1 {
print(i)
}
var primes = ""
for n in 0..LIMIT {
if !is_prime(n) {
continue
}
primes += "{n} "
}
print("primes:", primes)
var k = 0
for {
k += 1
if k == 3 {
break
}
}
print("k =", k)
}
+20
View File
@@ -0,0 +1,20 @@
sum 1..10 = 55
evens:
0
2
4
6
8
10
12
14
16
18
countdown:
5
4
3
2
1
primes: 2 3 5 7 11 13 17 19
k = 3
+48
View File
@@ -0,0 +1,48 @@
struct Team {
name: string
scores: map[string, int]
}
func total(m: map[string, int]): int {
var sum = 0
for k, v in m { sum += v }
return sum
}
func main() {
var ages = {"alice": 30, "bob": 25}
ages["carol"] = 41
ages["bob"] = 26
print(ages["bob"], ages.len(), ages.has("dave"), ages)
print(ages.get("alice"), ages.get("zed"), ages.get_or("zed", -1))
var counts: map[string, int] = {}
for w in "a b a c b a".split(" ") {
counts[w] += 1
}
print(counts)
for k, v in counts { print(k, "->", v) }
for k in counts.keys() { print("key", k) }
print(counts.values(), total(counts))
counts.remove("b")
print(counts, counts.len())
var copy = counts
copy["z"] = 9
print(counts.len(), copy.len())
var nums = map[int, []string]{}
nums[1] = ["x", "y"]
nums[2] = []
nums[1].push("z")
print(nums)
var t = Team{name: "red", scores: {"a": 1}}
t.scores["b"] = 2
var t2 = t
t2.scores["c"] = 3
print(t.scores.len(), t2.scores.len())
var big = map[int, int]{}
for i in 0..2000 { big[i * 7] = i }
var s = 0
for i in 0..2000 { s += big[i * 7] }
print(s, big.len())
for i in 0..1000 { big.remove(i * 7) }
print(big.len())
}
+16
View File
@@ -0,0 +1,16 @@
26 3 false {alice: 30, bob: 26, carol: 41}
30 nil -1
{a: 3, b: 2, c: 1}
a -> 3
b -> 2
c -> 1
key a
key b
key c
[3, 2, 1] 6
{a: 3, c: 1} 2
2 3
{1: [x, y, z], 2: []}
2 3
1999000 2000
1000
+23
View File
@@ -0,0 +1,23 @@
const PI = 3.14159
func area(r: float): float {
return PI * r * r
}
func average(a, b: int): float {
return float(a + b) / 2
}
func main() {
print("area:", area(2))
print("avg:", average(3, 4))
print(10 / 3, 10 % 3, 10.0 / 4)
print(int(7.9), float(3))
var x: float = 1
x *= 2.5
print(x, x > 2, -x)
print("whole float:", 2.0 * 3)
var big = 9223372036854775807
big += 1
print("wraps:", big)
}
+7
View File
@@ -0,0 +1,7 @@
area: 12.56636
avg: 3.5
3 1 2.5
7 3.0
2.5 true -2.5
whole float: 6.0
wraps: -9223372036854775808
+53
View File
@@ -0,0 +1,53 @@
struct User {
name: string
age: int
}
func find(id: int): User? {
if id == 1 {
return User{name: "Ann", age: 30}
}
return nil
}
func first_even(xs: []int): int? {
for x in xs {
if x % 2 == 0 { return x }
}
return nil
}
func describe(id: int): string {
var u = find(id)
if u == nil {
return "nobody"
}
return "{u.name} is {u.age}"
}
func main() {
print(describe(1))
print(describe(2))
var n = first_even([1, 3, 4, 5])
if n != nil {
print("first even:", n + 1)
}
var m: int? = first_even([1, 3])
print("m is", m)
print("n is", n)
var count: int? = 5
if count != nil && count > 3 {
print("big count")
}
count = nil
if count == nil || count > 100 {
print("no count")
}
var list: []int? = nil
if list == nil {
print("no list")
}
}
+8
View File
@@ -0,0 +1,8 @@
Ann is 30
nobody
first even: 5
m is nil
n is 4
big count
no count
no list
+33
View File
@@ -0,0 +1,33 @@
func say(msg: string, v: int): int {
print(msg)
return v
}
func add(a, b, c: int): int {
return a + b + c
}
func yes(msg: string): bool {
print(msg)
return true
}
func no(msg: string): bool {
print(msg)
return false
}
func main() {
print("arguments run left to right:")
print(add(say("first", 1), say("second", 2), say("third", 3)))
print("&& and || short-circuit:")
if no("A") && yes("B") {
print("unreachable")
}
if yes("C") || yes("D") {
print("done")
}
var ok = no("E") || yes("F") && yes("G")
print(ok)
}
+13
View File
@@ -0,0 +1,13 @@
arguments run left to right:
first
second
third
6
&& and || short-circuit:
A
C
done
E
F
G
true
+101
View File
@@ -0,0 +1,101 @@
enum Tok {
Word(w: string)
Num(n: int)
Many(parts: []string)
End
}
func name_of(t: Tok): string {
return match t {
Word(w) => w
Num(n) => "n{n}"
Many(ps) => ps[0] + "..."
End => "end"
}
}
func scan(ts: []Tok): (string, error) {
var acc = ""
for t in ts {
match t {
Word(w) => {
if w == "stop" { break }
if w == "skip" { continue }
acc += w + " "
}
Num(n) => {
if n < 0 { return error("negative " + name_of(t)) }
acc += "{n} "
}
Many(ps) => {
for p in ps {
if p == "x" { continue }
acc += p
}
}
End => { return acc, nil }
}
}
return acc + "|", nil
}
func grid(n: int): [][]string {
var g: [][]string
for i in 0..n {
var row: []string
for j in 0..n { row.push("{i}{j}") }
g.push(row)
}
return g
}
func longest(g: [][]string): string {
var best = ""
for row in g {
for cell in row {
if cell.len() >= best.len() { best = cell }
}
}
return best
}
struct Counter {
seen: []string
func note(s: string): int {
seen.push(s + "")
return seen.len()
}
}
func main() {
var ts = [Tok.Word("a"), Tok.Num(3), Tok.Many(["p", "x", "q"]), Tok.Word("skip"), Tok.Word("b")]
var r0, e0 = scan(ts)
print(r0, e0)
ts.push(Tok.Word("stop"))
ts.push(Tok.Word("never"))
var r, e = scan(ts)
print(r, e)
var bad = [Tok.Word("a"), Tok.Num(-4), Tok.End]
var r2, e2 = scan(bad)
print(r2, e2)
var ok = [Tok.Word("a"), Tok.End, Tok.Word("b")]
var r3, e3 = scan(ok)
print(r3, e3)
var g = grid(3)
g[1][1] = "mid" + "dle"
var h = g
h[0][0] = "changed"
print(g, longest(g), longest(h))
var c = Counter{}
var n = 0
for i in 0..3 { n += c.note("s{i}") }
print(n, c.seen)
var total = 0
for i in 0..50 {
var tmp = "item" + "{i}"
total += tmp.len()
if i % 7 == 0 { continue }
if i > 40 { break }
}
print(total)
}
+7
View File
@@ -0,0 +1,7 @@
a 3 pqb | nil
a 3 pqb | nil
negative n-4
a nil
[[00, 01, 02], [10, middle, 12], [20, 21, 22]] middle changed
6 [s0, s1, s2]
242
+101
View File
@@ -0,0 +1,101 @@
struct Person {
name: string
tags: []string
func greet(): string { return "hi " + name + "!" }
func rename(n: string) { name = n }
func add_tag(t: string) { tags.push(t) }
}
enum Msg {
Text(body: string)
Pair(a: string, items: []string)
Quit
}
func describe(m: Msg): string {
return match m {
Text(b) => "text:" + b
Pair(a, items) => "pair:" + a + "/" + "{items.len()}"
Quit => "quit"
}
}
func join(xs: []string, sep: string): string {
var out = ""
var first = true
for x in xs {
if !first { out += sep }
out += x
first = false
}
return out
}
func find(xs: []string, key: string): string? {
for x in xs {
if x == key { return x }
}
return nil
}
func fails(n: int): (string, error) {
if n > 2 { return error("too big: {n}") }
return "ok {n}", nil
}
func chain(): (string, error) {
var a = fails(1)?
var b = fails(2)?
var c = fails(3)?
return a + b + c, nil
}
func early(xs: []string): string {
var tmp = "tmp" + "1"
for x in xs {
var local = x + "!"
if local == "b!" { return local + tmp }
if local == "a!" { continue }
if local == "z!" { break }
}
return tmp
}
func main() {
var p = Person{"ann", ["x", "y"]}
print(p.greet())
p.rename("bob" + "by")
p.add_tag("z" + "z")
print(p.greet(), p.tags)
var q = p
q.rename("changed")
print(p.name, q.name)
var ms = [Msg.Text("hello"), Msg.Pair("k", ["1", "2"]), Msg.Quit]
for m in ms { print(describe(m)) }
print(join(["a", "b", "c"], ", "))
var words: []string
for i in 0..5 { words.push("w{i}") }
print(words, find(words, "w3"), find(words, "nope"))
var f = find(words, "w2")
if f != nil { print("found", f + "?") }
var s = "x"
for i in 0..4 { s = s + s }
print(s.len())
var v, e = fails(5)
print(v, e)
var w, e2 = chain()
print(w, e2)
print(early(["a", "c"]), early(["q", "b"]), early(["z"]))
var popped = words.pop()
print(popped, words.len())
words[0] = "first" + "!"
print(words)
var copy = words[1..3]
copy.push("end")
print(copy, words)
}
+16
View File
@@ -0,0 +1,16 @@
hi ann!
hi bobby! [x, y, zz]
bobby changed
text:hello
pair:k/2
quit
a, b, c
[w0, w1, w2, w3, w4] w3 nil
found w2?
16
too big: 5
too big: 3
tmp1 b!tmp1 tmp1
w4 4
[first!, w1, w2, w3]
[w1, w2, end] [first!, w1, w2, w3]
+82
View File
@@ -0,0 +1,82 @@
struct Item {
name: string
qty: int
}
struct Box {
items: []Item
label: string
func summary(): string { return label + ":" + "{items.len()}" }
func first(): Item? {
if items.len() == 0 { return nil }
return items[0]
}
}
func mk(n: string, q: int): Item { return Item{n + "_", q} }
func label_of(i: Item): string { return i.name + "#" + "{i.qty}" }
func fresh_box(l: string): Box { return Box{[mk("a", 1), mk("b", 2)], l + l} }
func pick(b: Box, k: int): (Item, error) {
if k >= b.items.len() { return error("no item {k} in " + b.label) }
return b.items[k], nil
}
func total(b: Box): (int, error) {
var t = 0
for i in 0..3 {
var it = pick(b, i)?
t += it.qty
}
return t, nil
}
func rec(n: int): string {
if n == 0 { return "." }
return "{n}" + rec(n - 1)
}
func cmp(a: string, b: string): bool { return a + "x" == b + "x" }
func check(s: string): error {
if s == "bad" + "!" { return error("bad input: " + s) }
return nil
}
func run(): error {
check("fine")?
check("bad" + "!")?
return nil
}
func main() {
print(label_of(mk("z", 9)), fresh_box("q").summary(), fresh_box("r").label)
var b = fresh_box("L")
b.label = b.label + "2"
b.items[0].name = "changed" + "!"
b.items.push(Item{"c", 3})
print(b.summary(), b.items)
var f = b.first()
if f != nil && f.name != "" { print(f.name) }
var it, err = pick(b, 7)
print(it, err)
var t, err2 = total(b)
print(t, err2)
print(rec(3), cmp("a", "a"), cmp("a" + "b", "a"))
var i = 0
for i < 3 && "{i}" != "2" { i += 1 }
print(i)
var msg = match i {
2 => "two" + "!"
_ => "other"
}
print(msg)
print(run())
var e = run()
if e != nil { print("failed:", e) }
var names: []string = ["m" + "1", "m" + "2"]
var out: []string
for n in names { out.push(n + n) }
names = out
print(names, out)
var opt: Item? = mk("o", 1)
if opt != nil { print(opt.name) }
opt = nil
print(opt)
var s = "a"
s += "b" + s
print(s)
}
+14
View File
@@ -0,0 +1,14 @@
z_#9 qq:2 rr
LL2:3 [Item{name: changed!, qty: 1}, Item{name: b_, qty: 2}, Item{name: c, qty: 3}]
changed!
Item{name: , qty: 0} no item 7 in LL2
6 nil
321. true false
2
two!
bad input: bad!
failed: bad input: bad!
[m1m1, m2m2] [m1m1, m2m2]
o_
nil
aba
+69
View File
@@ -0,0 +1,69 @@
struct Texture {
name: string
uses: int
func touch() { uses += 1 }
}
struct Sprite {
tex: shared Texture
x: int
}
struct Window {
title: string
buttons: []shared Button
func add(b: shared Button) { buttons.push(b) }
}
struct Button {
label: string
window: weak Window?
clicks: int
func click() {
clicks += 1
if window != nil {
print(label, "clicked in", window.title)
} else {
print(label, "clicked, window is gone")
}
}
}
func use_texture(t: shared Texture) {
t.touch()
}
func main() {
// several owners of one value: a change through one is seen by all
var tex = shared Texture{"grass", 0}
var a = Sprite{tex, 1}
var b = Sprite{tex, 2}
a.tex.touch()
b.tex.touch()
use_texture(tex)
print(tex.name, tex.uses, a.tex.uses, b.tex.uses)
print(a)
// a window and its buttons point at each other: the button's side is weak
var win = shared Window{"Main", []}
var ok = shared Button{"OK", weak win, 0}
win.add(ok)
ok.click()
win.buttons[0].click()
print(ok.clicks)
var cancel = shared Button{label: "Cancel"}
print(cancel.window == nil)
cancel.window = weak win
print(cancel.window == nil)
cancel.click()
// once the window is gone, the weak pointers know
var saved = ok
win = shared Window{"Other", []}
saved.click()
cancel.click()
}
+10
View File
@@ -0,0 +1,10 @@
grass 3 3 3
Sprite{tex: Texture{name: grass, uses: 3}, x: 1}
OK clicked in Main
OK clicked in Main
2
true
false
Cancel clicked in Main
OK clicked, window is gone
Cancel clicked, window is gone
+45
View File
@@ -0,0 +1,45 @@
func primes_up_to(n: int): []int {
var is_prime: []bool
for i in 0..n + 1 {
is_prime.push(true)
}
is_prime[0] = false
is_prime[1] = false
for i in 2..n + 1 {
if is_prime[i] {
for j in i * i..n + 1 step i {
is_prime[j] = false
}
}
}
var out: []int
for i, p in is_prime {
if p {
out.push(i)
}
}
return out
}
func bubble_sort(xs: []int): []int {
var n = xs.len()
for i in 0..n {
for j in 0..n - i - 1 {
if xs[j] > xs[j + 1] {
var tmp = xs[j]
xs[j] = xs[j + 1]
xs[j + 1] = tmp
}
}
}
return xs
}
func main() {
var ps = primes_up_to(60)
print(ps)
print("count:", ps.len())
var unsorted = [9, 4, 7, 1, 8, 2]
var sorted = bubble_sort(unsorted)
print(unsorted, "->", sorted)
}
+3
View File
@@ -0,0 +1,3 @@
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
count: 17
[9, 4, 7, 1, 8, 2] -> [1, 2, 4, 7, 8, 9]
+50
View File
@@ -0,0 +1,50 @@
struct Vec2 {
x, y: f32
func add(b: Vec2): Vec2 { return Vec2{x + b.x, y + b.y} }
func scale(k: f32): Vec2 { return Vec2{x * k, y * k} }
}
func average(a: u8, b: u8): u8 {
return u8((int(a) + int(b)) / 2)
}
func main() {
// literals take the type that is asked for
var small: u8 = 250
small += 10 // wraps around: 260 becomes 4
print(small)
var id: i8 = -128
print(id, id - 1)
var big: u64 = 5
big = big * 1000000000000
print(big, big / 7, big % 7)
var n: i32 = 2147483647
print(n + 1)
// f32 prints the shortest text that reads back the same
var speed: f32 = 1.1
print(speed, speed * 2, speed / 3)
var v = Vec2{1.5, 2}
print(v.add(Vec2{0.25, 0.25}).scale(2))
// conversions are explicit
var f = 3.99
print(int(f), u8(f), i8(-200.5), u8(300.7), f32(f))
print(u8(300), i16(70000), u32(-1), int(small) + 1)
print(average(200, 100))
print(u8(7) == 7, small < 10)
var xs: []u8 = [1, 2, 255]
xs[2] += 1
print(xs)
match id {
-128 => print("lowest i8")
_ => print("other")
}
}
+12
View File
@@ -0,0 +1,12 @@
4
-128 127
5000000000000 714285714285 5
-2147483648
1.1 2.2 0.36666667
Vec2{x: 3.5, y: 4.5}
3 3 -128 255 3.99
44 4464 4294967295 5
150
true true
[1, 2, 0]
lowest i8
+50
View File
@@ -0,0 +1,50 @@
import os
import math
import time
func count(path: string): (int, int, error) {
var text = os.read_file(path)?
var words = 0
var lines = 0
for line in text.lines() {
lines += 1
words += line.fields().len()
}
return lines, words, nil
}
func main() {
var csv = " alpha, beta ,gamma,, delta "
var parts = csv.split(",")
for p in parts { print("[" + p.trim() + "]") }
print(parts.len(), parts.join("|"))
print("Hello".upper(), "Hello".lower(), "a-b-c".replace("-", "+"), "ab".repeat(3))
print("hello".contains("ell"), "hello".starts_with("he"), "hello".ends_with("x"), "hello".index_of("l"), "hello".index_of("z"))
var n, err = "42".to_int()
print(n, err)
var bad, err2 = "4x2".to_int()
print(bad, err2)
var f, err3 = "2.5".to_float()
print(f * 2, err3)
print(math.sqrt(16), math.pow(2, 10), math.floor(2.7), math.round(2.5), math.PI)
print(math.min(3, 9), math.max(2.5, 1), math.abs(-7), math.abs(-2.5))
var small: u8 = 7
print(math.min(small, 200), math.max(small, 3))
var t0 = time.now()
time.sleep(0.01)
print(time.now() - t0 >= 0.01)
var err4 = os.write_file("/tmp/dino_std_test.txt", "one two\nthree\n\nfour five six\n")
print(err4)
var lines, words, e5 = count("/tmp/dino_std_test.txt")
print(lines, words, e5)
var l2, w2, e6 = count("/tmp/definitely/not/here.txt")
print(l2, w2, e6)
print(os.exists("/tmp/dino_std_test.txt"), os.exists("/nope"))
print(os.args.len(), os.env("HOME_NOPE_X") == nil)
var home = os.env("PATH")
if home != nil { print(home.len() > 0) }
os.exit(3)
}
+21
View File
@@ -0,0 +1,21 @@
[alpha]
[beta]
[gamma]
[]
[delta]
5 alpha| beta |gamma|| delta
HELLO hello a+b+c ababab
true true false 2 -1
42 nil
0 "4x2" is not a whole number
5.0 nil
4.0 1024.0 2.0 3.0 3.14159265358979
3 2.5 7 2.5
7 7
true
nil
4 6 nil
0 0 cannot read "/tmp/definitely/not/here.txt": No such file or directory
true false
1 true
true
+19
View File
@@ -0,0 +1,19 @@
func greet(name: string): string {
return "Hello, " + name + "!"
}
func main() {
var name = "Dino"
print(greet(name))
var n = 3
print("n is {n}, doubled {n * 2}, big? {n > 2}")
print("pi is about {3.5 + 0.25}")
print("a" < "b", "abc" == "abc", "x" != "x")
print("tab\there \"quoted\" \{braces}")
print("café ünï")
var s = ""
for i in 0..5 {
s += "{i},"
}
print(s)
}
+7
View File
@@ -0,0 +1,7 @@
Hello, Dino!
n is 3, doubled 6, big? true
pi is about 3.75
true true false
tab here "quoted" {braces}
café ünï
0,1,2,3,4,
+80
View File
@@ -0,0 +1,80 @@
struct Vec2 {
x, y: float
func add(b: Vec2): Vec2 {
return Vec2{x + b.x, y + b.y}
}
func scale(k: float): Vec2 {
return Vec2{x * k, y * k}
}
func length_squared(): float {
return x * x + y * y
}
}
struct Player {
name: string
pos: Vec2
vel: Vec2
hp: int
// changes pos and vel, so the compiler treats it as a mutating method
func update(dt: float) {
pos = pos.add(vel.scale(dt))
if pos.x < 0 || pos.x > 100 {
vel.x = -vel.x
}
if pos.y < 0 || pos.y > 100 {
vel.y = -vel.y
}
}
// calls a mutating method, so it mutates too
func step_twice(dt: float) {
update(dt)
update(dt)
}
func hurt(amount: int) {
hp -= amount
if hp < 0 {
hp = 0
}
}
func is_alive(): bool {
return hp > 0
}
func describe(): string {
return "{name} at ({pos.x}, {pos.y}) hp={hp}"
}
}
func main() {
var p = Player{name: "Ana", pos: Vec2{90, 50}, vel: Vec2{10, 5}, hp: 20}
print(p.describe())
p.update(1)
print(p.describe())
p.update(1)
print(p.describe())
p.step_twice(0.5)
print(p.pos)
// omitted fields start at zero
var q = Player{name: "Zed"}
print(q)
print(q.is_alive())
p.hurt(15)
p.hurt(15)
print(p.hp, p.is_alive())
var origin: Vec2
print(origin, origin.length_squared())
print(Vec2{3, 4}.length_squared())
}
+9
View File
@@ -0,0 +1,9 @@
Ana at (90.0, 50.0) hp=20
Ana at (100.0, 55.0) hp=20
Ana at (110.0, 60.0) hp=20
Vec2{x: 110.0, y: 65.0}
Player{name: Zed, pos: Vec2{x: 0.0, y: 0.0}, vel: Vec2{x: 0.0, y: 0.0}, hp: 0}
false
0 false
Vec2{x: 0.0, y: 0.0} 0.0
25.0
+49
View File
@@ -0,0 +1,49 @@
struct Counter {
n: int
func bump(): int {
n += 1
return n
}
}
struct Pair {
left: Counter
right: Counter
}
func bump_copy(c: Counter): int {
return c.bump()
}
func main() {
// assignment copies
var a = Counter{1}
var b = a
b.n = 100
print(a.n, b.n)
// passing to a function copies
print(bump_copy(a), a.n)
// methods change the variable they are called on
a.bump()
a.bump()
print(a.n)
// nested structs are copied as a whole
var p = Pair{Counter{10}, Counter{20}}
var q = p
q.left.bump()
p.right.bump()
p.right.bump()
print(p.left.n, p.right.n, q.left.n, q.right.n)
// reading before a later call in the same expression: the earlier read wins
var c = Counter{0}
print(c.n, c.bump(), c.n)
// constants can be read and used with non-mutating code
const k = Counter{7}
print(k.n)
}
+6
View File
@@ -0,0 +1,6 @@
1 100
2 1
3
10 22 11 20
0 1 1
7
+15
View File
@@ -0,0 +1,15 @@
// The shape of a parsed calculation.
pub enum Node {
Num(value: float)
Var(name: string)
Neg(inner: []Node)
Bin(op: string, sides: []Node)
Call(name: string, args: []Node)
Assign(name: string, value: []Node)
}
// Enums can't hold themselves directly, so children live in a list of one or two.
pub func neg(n: Node): Node { return Node.Neg([n]) }
pub func bin(op: string, l, r: Node): Node { return Node.Bin(op, [l, r]) }
pub func assign(name: string, v: Node): Node { return Node.Assign(name, [v]) }
+83
View File
@@ -0,0 +1,83 @@
// Evaluates a parsed calculation. Variables and functions live in `Scope`.
import ast
import math
pub struct Builtin {
pub name: string
pub arity: int
pub run: func([]float): float
}
pub struct Scope {
variables: map[string, float]
builtins: map[string, Builtin]
pub func set(name: string, v: float) {
variables[name] = v
}
pub func eval(n: ast.Node): (float, error) {
match n {
Num(v) => return v, nil
Var(name) => {
var v = variables.get(name)
if v == nil { return 0.0, error("unknown variable `{name}`") }
return v, nil
}
Neg(inner) => {
var x = eval(inner[0])?
return -x, nil
}
Assign(name, value) => {
var x = eval(value[0])?
set(name, x)
return x, nil
}
Bin(op, sides) => {
var a = eval(sides[0])?
var b = eval(sides[1])?
return apply(op, a, b)
}
Call(name, args) => {
if !builtins.has(name) { return 0.0, error("unknown function `{name}`") }
var b = builtins[name]
if args.len() != b.arity {
return 0.0, error("`{name}` takes {b.arity} argument(s), but {args.len()} given")
}
var vals: []float
for a in args { vals.push(eval(a)?) }
return b.run(vals), nil
}
}
}
func apply(op: string, a, b: float): (float, error) {
match op {
"+" => return a + b, nil
"-" => return a - b, nil
"*" => return a * b, nil
"/" => {
if b == 0.0 { return 0.0, error("division by zero") }
return a / b, nil
}
"%" => {
if b == 0.0 { return 0.0, error("division by zero") }
return a - b * math.floor(a / b), nil
}
"^" => return math.pow(a, b), nil
_ => return 0.0, error("unknown operator `{op}`")
}
}
}
pub func new_scope(): Scope {
var s = Scope{}
s.builtins["sqrt"] = Builtin{"sqrt", 1, a => math.sqrt(a[0])}
s.builtins["abs"] = Builtin{"abs", 1, a => math.abs(a[0])}
s.builtins["max"] = Builtin{"max", 2, a => math.max(a[0], a[1])}
s.builtins["min"] = Builtin{"min", 2, a => math.min(a[0], a[1])}
s.builtins["sum"] = Builtin{"sum", 3, a => a[0] + a[1] + a[2]}
s.set("pi", math.PI)
s.set("e", math.E)
return s
}
+43
View File
@@ -0,0 +1,43 @@
import parser
import eval
import os
// Evaluates one line and prints the answer or the problem.
func run_line(scope: shared eval.Scope, line: string) {
var text = line.trim()
if text == "" { return }
var tree, err = parser.parse(text)
if err != nil {
print(" error:", err)
return
}
var value, err2 = scope.eval(tree)
if err2 != nil {
print(" error:", err2)
return
}
print(" =", value)
}
// Reads lines from the file named on the command line, or from the keyboard.
func main() {
var scope = shared eval.new_scope()
var args = os.args
if args.len() > 1 {
var text, err = os.read_file(args[1])
if err != nil {
print("cannot read", args[1], err)
os.exit(1)
}
for line in text.lines() {
print(line)
run_line(scope, line)
}
return
}
for {
var line = os.read_line()
if line == nil { break }
run_line(scope, line)
}
}
+130
View File
@@ -0,0 +1,130 @@
// Recursive descent: assignment < + - < * / % < unary minus < ^ < calls and atoms.
import token
import ast
pub struct Parser {
tokens: []token.Token
at: int
func peek(): token.Token { return tokens[at] }
func next(): token.Token {
var t = tokens[at]
if at < tokens.len() - 1 { at += 1 }
return t
}
func is_op(text: string): bool {
var t = peek()
return t.kind == token.Kind.Op && t.text == text
}
func expect(kind: token.Kind, what: string): error {
if peek().kind != kind {
return error("expected {what} at column {peek().pos + 1}")
}
next()
return nil
}
pub func statement(): (ast.Node, error) {
// `name = expression`
if peek().kind == token.Kind.Name && at + 1 < tokens.len() {
var after = tokens[at + 1]
if after.kind == token.Kind.Op && after.text == "=" {
var name = next().text
next()
var value = sum()?
return ast.assign(name, value), finish()
}
}
var e = sum()?
return e, finish()
}
func finish(): error {
if peek().kind != token.Kind.End {
return error("unexpected `{peek().text}` at column {peek().pos + 1}")
}
return nil
}
func sum(): (ast.Node, error) {
var left = product()?
for is_op("+") || is_op("-") {
var op = next().text
var right = product()?
left = ast.bin(op, left, right)
}
return left, nil
}
func product(): (ast.Node, error) {
var left = unary()?
for is_op("*") || is_op("/") || is_op("%") {
var op = next().text
var right = unary()?
left = ast.bin(op, left, right)
}
return left, nil
}
func unary(): (ast.Node, error) {
if is_op("-") {
next()
var inner = unary()?
return ast.neg(inner), nil
}
return power()
}
func power(): (ast.Node, error) {
var base = atom()?
if is_op("^") {
next()
var exp = unary()?
return ast.bin("^", base, exp), nil
}
return base, nil
}
func atom(): (ast.Node, error) {
var t = next()
match t.kind {
Num => {
var v, err = t.text.to_float()
if err != nil { return ast.Node.Num(0.0), error("bad number `{t.text}` at column {t.pos + 1}") }
return ast.Node.Num(v), nil
}
Name => {
if peek().kind == token.Kind.Open {
next()
var args: []ast.Node
if peek().kind != token.Kind.Close {
args.push(sum()?)
for is_op(",") {
next()
args.push(sum()?)
}
}
expect(token.Kind.Close, "`)`")?
return ast.Node.Call(t.text, args), nil
}
return ast.Node.Var(t.text), nil
}
Open => {
var inner = sum()?
expect(token.Kind.Close, "`)`")?
return inner, nil
}
End => return ast.Node.Num(0.0), error("the calculation ends too early (column {t.pos + 1})")
_ => return ast.Node.Num(0.0), error("unexpected `{t.text}` at column {t.pos + 1}")
}
}
}
pub func parse(src: string): (ast.Node, error) {
var tokens = token.tokenize(src)?
var p = Parser{tokens, 0}
return p.statement()
}
+30
View File
@@ -0,0 +1,30 @@
1 + 2 * 3
= 7.0
(1 + 2) * 3
= 9.0
-2 ^ 2
= -4.0
2 ^ 3 ^ 2
= 512.0
x = 10 / 4
= 2.5
x * 2 + pi
= 8.14159265358979
sqrt(16) + abs(-3)
= 7.0
max(2, 7) % 4
= 3.0
y
error: unknown variable `y`
1 / 0
error: division by zero
foo(1)
error: unknown function `foo`
sqrt(1, 2)
error: `sqrt` takes 1 argument(s), but 2 given
3 +
error: the calculation ends too early (column 4)
4 $ 4
error: unexpected `$` at column 3
sum(1, 2, 3) * x
= 15.0
+15
View File
@@ -0,0 +1,15 @@
1 + 2 * 3
(1 + 2) * 3
-2 ^ 2
2 ^ 3 ^ 2
x = 10 / 4
x * 2 + pi
sqrt(16) + abs(-3)
max(2, 7) % 4
y
1 / 0
foo(1)
sqrt(1, 2)
3 +
4 $ 4
sum(1, 2, 3) * x
+49
View File
@@ -0,0 +1,49 @@
// Turns the text of a calculation into a list of tokens.
pub enum Kind {
Num
Name
Op
Open
Close
End
}
pub struct Token {
pub kind: Kind
pub text: string
pub pos: int
}
pub func tokenize(src: string): ([]Token, error) {
var tokens: []Token
var i = 0
for i < src.len() {
var c = src[i]
if c == ' ' {
i += 1
continue
}
var start = i
if c.is_digit() || c == '.' {
for i < src.len() && (src[i].is_digit() || src[i] == '.') { i += 1 }
tokens.push(Token{Kind.Num, src[start..i], start})
} else if c.is_letter() || c == '_' {
for i < src.len() && (src[i].is_alnum() || src[i] == '_') { i += 1 }
tokens.push(Token{Kind.Name, src[start..i], start})
} else if "+-*/^%=,".contains(string(c)) {
tokens.push(Token{Kind.Op, string(c), start})
i += 1
} else if c == '(' {
tokens.push(Token{Kind.Open, "(", start})
i += 1
} else if c == ')' {
tokens.push(Token{Kind.Close, ")", start})
i += 1
} else {
return tokens, error("unexpected `{c}` at column {i + 1}")
}
}
tokens.push(Token{Kind.End, "", src.len()})
return tokens, nil
}
+13
View File
@@ -0,0 +1,13 @@
// A module: everything marked `pub` can be used by the file that imports it.
import math
pub const UNIT = 1.0
pub struct Point {
pub x, y: float
pub func dist(other: Point): float {
return math.sqrt((x - other.x) * (x - other.x) + (y - other.y) * (y - other.y))
}
}
pub func origin(): Point { return Point{0.0, 0.0} }
+6
View File
@@ -0,0 +1,6 @@
import geometry
func main() {
var p = geometry.Point{3.0, 4.0}
print(p.dist(geometry.origin()), geometry.UNIT)
}
+6
View File
@@ -0,0 +1,6 @@
1 100
2 1
3
10 22 11 20
0 1 1
7