all.klar

/// This file uses all syntax features in Klar. This can be
/// used to test the parser and type checker.
/// TODO: Fix reference errors

// This is a line comment
/* This is a 
    block comment
*/
/* This
    is /* a nested
    block comment */ */

// Imports
//import klar.io // Standard library import
//import klar.io.{Readable, Writable}
//import klar.io.{Readable as MyName, Writable}
//import klar.*
//import system = klar.os

// Declarations
basicVar := "Hello"
basicVarWithAnnot: String := "World"

var1, var2 := 1
var3, var4 := 2, 3
var5, var6: Int := 4, 5
var7, var8: Int := 6
var9, var10, var11 := 7

type ReturnType = Nothing

func function() {}
func function(param: Int) -> ReturnType {}
func function2(label param: Int) = 1 + param
func function3(label1 param1, label2 param2: Int) -> Int {}
func withResult() -> Result<Int> {}

func alias = function
func Struct.alias = .method

// Assignment
basicVar += ", World!"
basicVar = "Klar is awesome!"
basicVar += " "
basicVar *= 3
// Compound assignments
_ = 1
_ := 1
_ += 1
_ -= 1
_ *= 1
_ /= 1
_ ^= 1
_ %= 1

// Type Declarations
type #Tag
type #Inherited
type #Tag2: Inherited
type Struct {
    field: Int
    field2, field3: String
    fieldWithDefault: Int = 1
}
type Struct2: Inherited {}
type #Interface {
    field: Int
    field2, field3: String
    method()
    methodWithParam(param: String)
    methodWithParam2(String)
    methodWithLabelledParam(label param: String)
    methodWithLabelledParam2(label _: String) -> ReturnType
    methodWithReturn() -> Bool
}
type #Interface2: Inherited, Inherited2 {}
type Enum {
    .some
    .none
    .withParams(String, Int)
    .withLabelledParams(a: String, b: Int)
    .withLabelledParams2(a, b: Int)
}
type GenericEnum<T> { .some(T) }
type Alias = String

// Types
type Union = Int | Float
type StringList = [String]
type StringMap = #{String: String}
type StringResult = Result<String>
type StringResult2 = Result<String, Error>
type StringResultOrCustomError = Result<String, CustomError>
type Outcome = Result<Nothing>
type Optional = Int?
type Tuple = (Int, String)
type Tuple2 = (k: Int, v: String)
type Tuple3 = (k, v: Int)
type _ = GenericEnum<Int>
type Function = func()
type Function2 = func(String)
type Function3 = func(a, b: Int) -> Nothing
type Function4 = func(a: Int, b: String)

// Attributes
@deprecated
func deprecatedFunc() {}

@external(.js, file: "#/myfunc.js", export: "default")
func myFunc()

@external(.js, file: "#/myfunc.js", export: "default")
@deprecated(since: v1.4.2)
func myFuncWithFallback() { crashout("Unsupported") }

@added(v1)
@deprecated(since: v1.4)
func _()

// Literals
function()
nilValue: Int? := nil
_ = (
    // String
    "Hello", 'Hello', "Hello {1 + 1}",
    `Hello
    World!`,
    // Int
    23333, -27272, (1 + 1),
    0xfff, 0xc0fefe, 0xc0_fe_fe,
    0b10101, 0b110_10,
    // Float
    0.18728, 0.172_228,
    10e5, 0.272e3, 10e4_2, 10.42e6_2,
    // Bool and nil
    false, true, nilValue, Optional(nil),
    // List
    [], [1, 2, 3], [[1, 2, 3]..., whatever...],
    // Map
    #{}, #{a: 1, b: 2, "c": 3, ("Hello" + " World!"): 4},
    #{
        #{a: 1}..., // Rest
        :b, // Shorthand
        c: 1,
    },
)

// Tuples
_ = (
    (1, 2, 3),
    (1,),
    (1, 2),
)

// Operators
arithmetic := (
    1 + 1, 2 - 1,
    3 * 5, 12 / 4, 11 % 10,
    2 ^ 3, -2 ^ 4 /* -16 */, (-2) ^ 4 /* 16 */,
)
logical := (
    true && false, true || false,
    !true,
    1 + 1 == 2 || 1 * 3 > 6,
)
relational := (
    1 == 1, 1 != 2,
    1 < 2, 2 > 1,
    1 <= 1, 2 >= 1,
    // Chained comparisons
    1 < 2 < 3,
    1 >= 2 >= 3,
    1 < 2 == 2 < 3,
)
x := 1
distributive := (
    x == 3 or 4,
    x != 1 and 5,
    x == 3 or 4 or 5,
)
list := [1, 2, 3, 4, 5]
contains2 := 2 in list
excludes6 := 6 !in list

type Object { name: String }
object := Object(name: "John")
object = Object("John")
object = .("John")

// Index
object.name = "John"
map := #{'key1': #{'key2': 2, 'key3': 3}, 'key4': #{}}
_ = (
    object.name.length,
    map['key1']!!['key2'],
    map.key1["key2"],
    map['key1']!!.key2,
)

// List slicing
_ = (
    list[1..<3],
    list[1...],
    list[1...3],
    list[...6],
)

// Ranges
closedRange := 1...10 // 11 items
openRange := 1..<10 // 10 items

// Try
_ = try withResult()

// Assertion
optional: Int? := 1
result: Result<Int> := 2
print(optional!!, result!!)

// Casts
_ = [Int]()
_ = #{String: Int}()

// Lambdas
_ = (
    func {},
    func (x: Int) {},
    func (x: Int) -> x,
    func (x: Int = 1) -> x,
)
_: func(Int, Int) -> Int := func x, y -> x + y

// Enum literals
_: (Enum, Enum) := (Enum.some, .some)

// Go/Await
func fn() = 1
task := go fn()
task2 := go { print("Running in parallel") }
go {}
await task
await (task, task2)
_ = await task

// Pipeline
// Object pipeline
//lol