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:
1 parent
3e2779f447
commit
eaf9567a36
117 files changed
+19970
No files matched your search
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)) }
|
||||
}
|
||||
@@ -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
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -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))
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
sum = 3
|
||||
failed: not a digit: x
|
||||
ok is nil
|
||||
5 is fine
|
||||
@@ -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)}")
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
@@ -0,0 +1,3 @@
|
||||
func main() {
|
||||
print("Hello, Dino!")
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
Hello, Dino!
|
||||
@@ -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))
|
||||
}
|
||||
@@ -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
|
||||
@@ -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())
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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]
|
||||
@@ -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())
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
@@ -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())
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
Ann is 30
|
||||
nobody
|
||||
first even: 5
|
||||
m is nil
|
||||
n is 4
|
||||
big count
|
||||
no count
|
||||
no list
|
||||
@@ -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)
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
arguments run left to right:
|
||||
first
|
||||
second
|
||||
third
|
||||
6
|
||||
&& and || short-circuit:
|
||||
A
|
||||
C
|
||||
done
|
||||
E
|
||||
F
|
||||
G
|
||||
true
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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]
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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]
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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,
|
||||
@@ -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())
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
1 100
|
||||
2 1
|
||||
3
|
||||
10 22 11 20
|
||||
0 1 1
|
||||
7
|
||||
@@ -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]) }
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
@@ -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} }
|
||||
@@ -0,0 +1,6 @@
|
||||
import geometry
|
||||
|
||||
func main() {
|
||||
var p = geometry.Point{3.0, 4.0}
|
||||
print(p.dist(geometry.origin()), geometry.UNIT)
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
1 100
|
||||
2 1
|
||||
3
|
||||
10 22 11 20
|
||||
0 1 1
|
||||
7
|
||||
Reference in new issue
Block a user