test.inko

import std.stdio (Stdout)

type pub Person {
  let @name: String
  let @age: Int
}

type enum Result[T, E] {
  case Ok(T)
  case Err(E)

  fn ok? -> Bool {
    match self {
      case Ok(_) -> true
      case _ -> false
    }
  }
}

type pub async Testing {
  let @values: Array[uni Thing]
}

trait ToFoo {
  fn to_foo -> String

  fn to_bla(arg: Int) -> Int {
    arg * 2
  }
}

impl Thing for AnotherThing {

}

impl Thing {

}

fn pub inline example {}

type pub inline InlineType {
  fn pub inline foo {}
  fn pub inline mut bar {}
  fn pub inline move baz {}
}

type pub inline enum InlineEnum {}

type pub copy enum CopyEnum {}

type pub copy CopyType {}

type async Main {
  fn async main {
    10.2
    10.2e5
    100
    100_000
    0xdeadbeef
    "double quoted string"
    "string with \u{fff} escape sequences \n\r\t"
    "string with {10 + 5} interpolation"
    "string with a #comment in it"
    'single qouted string'
    "string that spans
    multiple
    lines"

    10 / 20
    10.5 + 1.2
    1 << 3

    # A comment
    identifier
    @field_reference
    method()
    self
    self.foo(10, 20)
    self.bar(number: 20, bla, 30)
    Stdout.new.print('hello')
    (10, 20)
    [10, 20, 30]
    {
      # ...
    }

    return 42
    throw 42
    try foo

    # A closure
    fn (number) -> Int { return number * 2 }
    fn (a: Int) -> Int { a * a }
  }
}