; fun foo(a: int): int {
;     1
; }
; fun bar(): int {
;     fun foo(): int 1 + 2
;     1 
; }
struct vec {
    x: f64
    y: f64
    huh: {
        z: int
        id: str
    }
}
let a = 1

match a {
    case 1 = "ha"
    case 2 = "ho"
}

cond {
    1 == 1 = "ha"
    2 != 2 = "ho"
}

; struct vec {
;     x: f64
;     y: f64
;     huh: {
;         z: int
;         id: str
;     }
; }

; let v: vec = vec : {
;     x = 10.0
;     huh = {
;         z = 10
;         id = "blah"
;     }
; }

; fun foo(): nil {
;     struct vec {
;         z: f64
;     }
;     let a: vec
;     set a.z = 1.0
; }

; struct vec {
;     x: f64 = 2.0
;     y: f64 = 1.0
;     bruh: {
;         id:  int = 10
;         msg: str = "hello"
;         inner: {
;             x: int = 32
;             y: str
;         }
;     }
; }

; let v: vec
; set v.x = 1.0
; set v.bruh.id = 1
; set v.bruh.inner.y = "yo"

; set v = vec : { 
;     x = 1.0 
;     y = 32.0
;     ; bruh = dud : {
;     ;     id = 1
;     ; }
; }

; struct person {
;     name: str = "joe"
;     age: int = 18 * 2
; }

; ; We can use the dot operator to access fields.
; let player_a: person
; set player_a.name = "alex"

; struct vec {
;     x: f64
;     y: f64
;     z: f64
; }
; let v = vec : { x = 1.0 }

enum weekdays {
    mon = 1
    tue
    wed
    thu
    fri
    sat
    sun
}
let d = weekdays.tue
; let b = a

match 1 {
    case 2 = "monday"
    case 3 = "tuesday"
    else = "whateverday"
}

match d {
    case mon = "monday"
    case tue = "tuesday"
    else = "whateverday"
}

; struct item {
;     id: int
;     name: str
; }

; ; let a: item = item {
; ;     id = 1
; ; }
; ; let a: item = item ; this shouldn't work, or should it return the default val?
; let c: item
; set c.id = 1
; let d = c.id
; set a.name = "hello"
; let b = a.id
; let c = a.name

; fun add10(a: int, b: str): int {
;     a + 10
; }

; fun foo(): int {
;     add10(1, "hello")
; }

; let a:f32 = (1.0 + 2.0 * 2.0) / 2.0

; let annotated:int = (1 + 2 * 2) / 2
; let numbers = 1
; let symbols = numbers
; let arith = 1 + 2 * 4
; let cmp = 1 <= 2
; let logic = !true && false || (1 <= 2)
; let bits = 0xff & 0b00001111
; let block = {
;     let a = 1 + 2
;     a + 3
; }

; let maybe = if (1 == 2) {
;     32
; } else {
;     44
; }

; let single = if (true) {
;     123
; }

; while (!true) {
;     "asjdflasdjf"
; }

; set single = 32

; cond {
;     1 == 2 = "hello"
;     else = "dong"
; }

; enum test {
;     a = 1
;     b
; }
; ; Resolve struct accessors.
; struct my_struct {
;     field_a: int
;     field_b: int
; }

; let a:my_struct
; set a.field_a = 1

; fun nested(): int {
;     fun adder(a: u32, b: u32): u32 {
;         a + b
;     }
;     if (1 + 1 == 2) {
;         let b = 15
;         {
;             let c = 32
;             5 + c
;         }
;     }
; }

; enum field {
;     a
;     b
; }

; struct vec {
;     a: int
;     b: int
; }

; fun foo(): nil {
;     bar()
; }

; fun bar(): nil {
;     foo()
; }

; ; There are some builtint functions.
; println("hello world")

; ; Let/set.
; let num = 1
; set num = 2
; set num = 0 + num

; ; Loops and conditionals.
; if (num) 3 else 1
; let val = if (2 + num == 4) num else num
; if (true) {
;     let c = 1
;     1 + 1 + c
; }

; fun testmatches(num: int): int {
; ;     match (num) {
; ;         case 1 = 23
; ;         case 2 = num
; ;         else = num
; ;     }

;     cond {
;         1 == 1 = 23
;         2 != 1 = num
;         else = num
;     }
; }

; while (num == 1) num
; while (true) {
;     let c = 1
;     1 + 1 + c
; }
; fun foo(a: int b: str): (f64, f64) {
;     fun bar(): nil {
;         println("ding")
;     }
;     if (a == 1) {
;         ; return("test", b)
;         return (3.0, 4.0)
;     }
;     return (1.0, 2.0)
; }

; let b = a
; let a = a
; set a = 10
; set num = 1 << a
; baz()
; if (a) 1
; if (num == 1) a
; if (num == 1) 1 else a