Process files and emit Go code
Standalone expressions
use fmt
fn main() {
fmt.Printf("hello %v", 4)
}Function calls
fn foo(b: bool, x: int) -> bool { b }
fn bar(x: int) -> int { x }
fn baz() {}
fn main() {
let val = foo(match 1 {
1 => true
_ => false
}, bar(5))
assertEq(val, true)
}Let bindings
fn main() {
let a = 5 + 5
assertEq(a, 10)
}If statements
fn main() {
let x = if true { 6 } else { 0 }
assertEq(x, 6)
}Enums
enum Foo {
Bar(int, bool),
Baz,
}
fn main() {
inspect(Foo.Bar(2, false))
inspect(Foo.Baz)
}Structs
struct Bar<T> {
name: string,
age: int,
v: T,
}
fn main() {
let x = Bar { name: "yo", age: 99, v: false }
inspect(x)
}Return statement
fn foo() -> int {
let x = match 1 {
1 => return 12
_ => 5
}
if true {
let _ = x + 40
} else {
return 9
}
return 4
}
fn bar() {
if false {
return
}
}
fn main() {
assertEq(foo(), 12)
}Struct access
struct Foo {
a: int,
b: string,
c: bool,
}
fn main() {
let x = Foo { a: 1, b: "hi", c: true }
assertEq(x.a, 1)
let y = Foo { a: 5, c: false, ..x }
assertEq(y.a, 5)
assertEq(x.a, 1)
}Try operator
use errors
fn foo(b: bool) -> Result<int> { bar("a") }
fn bar(s: string) -> Result<int> {
Err(errors.New("boom"))
}
fn baz() -> Result<int> {
let _ = foo(false)?
@unreachable()
Ok(1)
}
fn as_value() -> Result<int> {
let a = baz()
a
}
fn as_param(r: Result<int>) -> bool {
r.IsOk()
}
fn main() {
assertEq(baz(), Err(errors.New("boom")))
assertEq(as_value().IsOk(), false)
assertEq(as_param(Ok(1)), true)
}Destructure function params
fn foo((_, b): (int, string)) -> string {
b
}
fn main() {
assertEq(foo((1, "yo")), "yo")
}Lists
fn main() {
let mut x = [1, 2, 5 + 5]
inspect(x)
assertEq(x.Len(), 3)
assertEq(x[1], 2)
x[1] = 8
assertEq(x[1], 8)
x = x.Append(9)
assertEq(x[3], 9)
}Impl blocks
struct Foo { a: int }
impl (f: Foo) {
fn bar(x: int) -> int {
f.a + x
}
}
fn main() {
let f = Foo { a: 1 }
assertEq(f.bar(5), 6)
}Rebind variables
fn main() {
let x = 1
assertEq(x, 1)
let x = 1 + 1
assertEq(x, 2)
{
let x = x + 5
assertEq(x, 7)
}
assertEq(x, 2)
}Concurrency
use sync
use fmt
fn main() {
let (sender, receiver) = Channel.new()
fn foo(x: int) {
sender.Send(x)
}
spawn (|| { sender.Send(5) })()
let val = receiver.Recv()
assertEq(val, 5)
spawn foo(10)
let val = receiver.Recv()
assertEq(val, 10)
{
let desired = 5
let wg: sync.WaitGroup = zeroValue()
wg.Add(desired)
let (done_tx, done_rx) = Channel.new()
// receiver goroutine
spawn (|| {
let mut count = 0
for n in receiver {
count = count + n
}
assertEq(count, 10)
fmt.Printf("count: %v", count)
done_tx.Send(())
})()
let mut i = 0
// start `desired` goroutines
while (i < desired) {
spawn (|i| {
sender.Send(i)
wg.Done()
})(i)
i = i + 1
}
wg.Wait()
sender.Close() // close(sender)
done_rx.Recv() // <-done
}
}Math with floats
fn main() {
let x = 5.3 * 1.2
assertEq(true, x > 6.35 && x <= 6.36)
}Early returns in blocks.
fn foo() -> int {
{
return 5
}
999
}
fn main() {
assertEq(foo(), 5)
}Recursive functions are supported in files.
file: main.brg
fn foo(n: int) -> int {
if n != 5 {
return foo(n + 1)
}
n
}
fn main() {
assertEq(foo(1), 5)
}Mutually recursive functions
file: main.brg
fn abs(n: int) -> int {
if n < 0 { return -n }
n
}
fn even(n: int) -> bool {
if n == 0 {
return true
}
odd(abs(n) - 1)
}
fn odd(n: int) -> bool {
if n == 0 {
return false
}
even(abs(n) - 1)
}
fn main() {
assertEq(even(10), true)
}Multiple files
file: foo.brg
enum Foo {
X(Bar),
}
file: bar.brg
enum Bar {
A(int),
}
fn with_foo(f: Foo, m: int) -> int {
match f {
Foo.X(b) => match b {
Bar.A(n) => n + m
}
}
}
file: main.brg
fn main() {
let bar = Bar.A(2)
assertEq(with_foo(Foo.X(bar), 3), 5)
}Recursion across files
file: a.brg
fn a(n: int) -> int {
if n == 100 {
return n
}
b(n + 10)
}
file: b.brg
fn b(n: int) -> int {
if n == 200 {
return n
}
a(n + 20)
}
file: main.brg
fn main() { assertEq(a(40), 100) }Match on structs
struct Foo { a: int }
fn main() {
let x = Foo { a: 1 }
let res = match x {
Foo { a: 2 } => false
Foo { a: 1 } => true
Foo { a: _ } => false
}
assertEq(res, true)
}Const expressions are global
file: main.brg
const a: int = 1
fn main() { assertEq(a + 5, 6) }Const expressions are visible from other files
file: foo.brg
fn check() -> bool {
foo == 2
}
file: main.brg
const foo: int = 1 + 1
fn main() { assertEq(check(), true) }Paren expressions
fn main() {
assertEq((1 + 4), 5)
}Recursive types
enum Expr {
Add(*Expr, *Expr),
Number(int),
}
impl (e: Expr) {
fn sum() -> int {
match e {
Add(a, b) => a.sum() + b.sum()
Number(n) => n
}
}
}
struct Foo {
n: string,
f: *Option<Foo>,
}
fn main() {
let one = Expr.Number(1)
let two = Expr.Number(2)
let e = Expr.Add(&one, &two)
assertEq(e.sum(), 3)
let f1 = None
let nope = Foo { n: "a", f: &f1 }
let f2 = Some(nope)
let yep = Foo { n: "b", f: &f2 }
assertEq(yep.n, "b")
}Recursive functions should work even when not declared at the top-level.
fn main() {
fn foo(n: int, acc: int) -> int {
if n == 0 {
return acc
}
let new_acc = if n % 2 == 0 {
acc + n
} else {
acc
}
foo(n - 1, new_acc)
}
assertEq(foo(10, 0), 30)
}Exhaustiveness checking on bools
fn main() {
let x = match false {
true => @unreachable()
false => 2
}
assertEq(x, 2)
}Primitive types are casted in struct call
struct Foo {
bar: int,
}
fn main() {
let x = 1
let y = Foo { bar: x }
assertEq(y.bar, 1)
}Match on tuples
fn main() {
let res = match (1, "foo") {
(3, _) => 5
(1, "bar") => 6
(x, "foo") => x
_ => @unreachable()
}
assertEq(res, 1)
let res = match () {
() => 2
}
assertEq(res, 2)
}Enums in tuples
enum Foo { Bar, Baz }
fn main() {
let res = match (Bar, Baz) {
(Bar, Bar) => 0
(Bar, Baz) => 2
_ => @unreachable()
}
assertEq(res, 2)
}Let binding same name as function param
fn foo(xs: [int]) -> int {
// TODO asdf make sure params are put in scope so they can be rebound
// let xs = xs.Len()
// xs + 10
let xxxs = xs.Len()
xxxs + 10
}
fn main() {
assertEq(foo([1,2,3]), 13)
}Maps in structs
struct Foo {
bar: Map<string, int>
}
fn main() {
let mut bar = Map.new()
let foo = Foo { bar }
assertEq(foo.bar.Len(), 0)
bar.Insert("yo", 1)
assertEq(foo.bar.Len(), 1)
assertEq(bar.Get("yo"), Some(1))
assertEq(bar.Get("nope"), None)
assertEq(bar["yo"], 1)
bar["yo"] = 3
assertEq(bar["yo"], 3)
}Functions in structs
struct Foo {
bar: fn (a: int) -> int,
}
fn main() {
let foo = Foo { bar: |x: int| x + 2 }
assertEq(foo.bar(1), 3)
}Records have stable field order.
struct Foo { x: int, y: string }
fn main() {
inspect((1, "a", true))
inspect(Foo { x: 1, y: "b" })
}Using for loops.
fn main() {
{
let mut sum = 0
// this should iterate over values
for x in [1, 2, 3] {
sum = sum + x
}
assertEq(sum, 6)
}
{
let mut sum = 0
for (i, x) in [1, 2, 3].Enumerate() {
sum = sum + i + x
}
assertEq(sum, 9)
}
{
let str = "asdf"
let mut check = ""
for c in str {
check = check + string(c)
}
assertEq(str, check)
let mut check = ""
for (index, c) in str.Enumerate() {
inspect(index)
check = check + string(c)
}
assertEq(str, check)
}
let mut n = 20
match true {
true => {
n = 25
}
false => ()
}
loop {
if n > 27 {
break
}
inspect(n)
n = n + 1
}
n = 0
while n < 10 {
n = n + 1
}
inspect(n)
let m = Map.new()
m.Insert("a", 1)
for (k, v) in m {
inspect(k)
inspect(v)
}
}Control flow in loops
fn main() {
let mut n = 0
let mut check = false
loop {
if n <= 5 {
n = n + 1
assertEq(check, false)
continue
}
check = true
break
}
assertEq(check, true)
assertEq(n, 6)
n = 0
for x in [1,2,3] {
if x == 2 {
continue
}
n = n + 1
}
assertEq(n, 2)
}Mutating vars
fn foo(a: int) -> int {
loop {
if a > 5 { break }
a = a + 1
}
a
}
fn main() {
let mut x = 1
x = x + 3
assertEq(x, 4)
{
let x = 5
assertEq(x, 5)
}
assertEq(foo(0), 6)
// TODO this doesn't type check :/
// x = x + 6
// x.assertEq(10)
}Nested if and match maintain context.
fn foo() -> int {
if 1 > 2 {
1
} else if 2 > 3 {
2
} else {
3
}
}
fn bar() -> int {
match 1 {
1 => match 2 {
3 => 4
_ => 5
}
_ => 9
}
}
fn main() {
assertEq(foo(), 3)
assertEq(bar(), 5)
}Lambda signature
fn compute(f: fn(a: int, b: int) -> int) -> int {
f(3, 4)
}
fn main() {
assertEq(compute(|a, b| a + b), 7)
}Read file
use os
use fmt
fn read() -> Result<()> {
let f = os.ReadFile("go.mod")?
fmt.Println(string(f))
Ok(())
}
fn main() {
read().Unwrap()
}Native call to result
use os
use fmt
fn main() {
match os.ReadFile("go.mod") {
Ok(s) => fmt.Println(string(s))
Err(_) => @unreachable()
}
}Compile references
use fmt
struct Foo {
x: int,
}
fn bar(f: *Foo) -> int {
f.x + 2
}
fn baz(i: *int) {
i.* = 99
}
fn main() {
fmt.Printf("%v", bar(&Foo { x: 1 }))
let mut n = 1
baz(&n)
assertEq(n, 99)
}References in structs
use fmt
struct Foo {
x: int,
}
struct Bar {
f: *Foo,
}
fn update(b: *Bar) {
b.f.x = 99
}
fn main() {
let f = Foo { x: 1 }
let mut b = Bar { f: &f }
update(&b)
assertEq(b.f.x, 99)
fmt.Printf("%+v", b.f)
}References in methods
struct Foo {
x: int,
}
impl (f: *Foo) {
fn update(x: int) {
f.x = x
}
}
fn main() {
let f = Foo { x: 1 }
f.update(5)
assertEq(f.x, 5)
}Interfaces
interface Foo {
fn foo() -> int
}
struct Bar { x: int }
impl (b: Bar) {
fn foo() -> int {
b.x
}
}
fn baz(f: Foo) -> int {
f.foo() + 4
}
interface Composite {
impl Foo
}
fn check_composite(c: Composite) {
c.foo()
}
fn main() {
assertEq(baz(&Bar { x: 6 }), 10)
}Types implement interfaces
use fmt
struct Foo {}
impl (f: Foo) {
fn Write(bytes: [byte]) -> Result<int> {
Ok(3)
}
}
fn main() {
let n = fmt.Fprintf(&Foo{}, "%d", 1).Unwrap()
assertEq(n, 3)
}Net http
use fmt
use net.http
use net.http.httptest
use io
use sync
struct Counter { m: sync.Mutex, count: int }
impl (c: *Counter) {
fn ServeHTTP(w: http.ResponseWriter, r: *http.Request) {
c.m.Lock()
c.count = c.count + 1
fmt.Fprintf(w, "<h1>count %d</h1>", c.count)
c.m.Unlock()
}
}
fn main() {
let c = Counter { m: zeroValue(), count: 0 }
let ts = httptest.NewServer(&c)
defer ts.Close()
let res = http.Get(ts.URL).Unwrap()
let body = io.ReadAll(res.Body).Unwrap()
res.Body.Close()
fmt.Println(string(body))
}Trait bounds without methods are not checked
// Let the Go compiler figure out if a type satisfies a constraint
fn foo<T: comparable>(x: T, y: T) -> bool {
x == y
}
interface Foo {
fn check() -> int
}
struct Bar {}
impl (b: Bar) {
fn check() -> int { 3 }
}
// Check that multiple constraints are correctly emitted
fn bar<T: comparable + Foo>(x: T, y: T) -> int {
if x == y {
x.check()
} else {
-1
}
}
fn main() {
assertEq(foo(1.0, 2.0), false)
assertEq(foo(1, 1), true)
assertEq(bar(Bar{}, Bar{}), 3)
}Variadic function calls
use fmt
fn foo(a: bool, x: VarArgs<int>) {}
fn main() {
fmt.Printf("yep %s, %d", "hi", 3)
foo(false, 1, 2)
}Package structs
use os
fn main() {
let _ = os.Process { Pid: 99 }
}Options
use os
fn foo() -> Option<int> {
Some(3)
}
fn main() {
let x = foo()
assertEq(x.IsSome(), true)
match os.LookupEnv("HOME") {
Some(_) => ()
None => @unreachable()
}
}Errors as custom types
fn foo() -> Result<(), FooErr> {
Ok(())
}
struct FooErr {}
impl (f: FooErr) {
fn Error() -> string { "b" }
}
fn bar() -> Result<(), error> {
let x = foo()?
Ok(x)
}
fn main() {
let x = foo()
let y = bar()
assertEq(x, Ok(()))
assertEq(y, Ok(()))
}Blocks used as expressions
use math
fn main() {
let block_result = {
let a = math.Pi
let b = 2.01
a + b
}
assertEq(block_result > 4.0, true)
}Defer statements
use fmt
fn main() {
fmt.Println("first")
defer fmt.Println("defer 1")
fmt.Println("second")
defer (|| { fmt.Println("defer 2") })()
}Newline characters
use fmt
fn main() {
let x = '\n'
fmt.Printf("a%sb\n", x)
let y = \\a string
\\ with " quotes and \ backslashes
fmt.Println(y)
}Referenced packages are imported
use fmt
use os
fn main() {
let dir = os.ReadDir(".").Unwrap()
fmt.Printf("%v", dir[0])
}Unwrapped call in loop
use fmt
use os
fn foo() -> Result<()> {
for f in os.ReadDir(".")? {
if f.Name() == "go.mod" {
fmt.Println("ok")
}
}
Ok(())
}
fn main() {
foo().Unwrap()
}Math with newtypes
use fmt
use time
fn main() {
time.Sleep(0 * time.Second)
fmt.Println(2 * time.Second)
}Select statement
use fmt
fn main() {
let (tx, rx) = Channel.new()
spawn (|| {
tx.Send(1)
})()
select {
let foo = rx.Recv() => {
fmt.Println("foo", foo)
}
}
spawn (|| {
let bar = rx.Recv()
fmt.Println("bar", bar)
})()
select {
tx.Send(5) => fmt.Println("sending")
}
select {
_ => fmt.Println("default")
}
}