plum

import std/Str

import std/Bool

import std/Number

fun addInts(a: Int, b: Int) -> Int =

  a + b

fun greet() =

  todo

fun withDefault(a: Int, step: Int = 1) -> Int =

  a + step

fun sumAll(nums: ...Int) -> Int =

  total := 0

  for v := range nums

    total = total + v

  total

fun wrap(value: T) -> Bool =

  True

fun pair(first: T, second: U) -> Bool =

  True

fun useWrap() -> Bool =

  wrap(5)

fun usePair() -> Bool =

  pair(1, "x")

# ---- generics, variadics, and misc regression tests ----

fun factorial(x: Int) -> Int =

  if x < 2

    return 1

  return x * factorial(x - 1)

# Regression test: `double(...)` (an all-lowercase, no-uppercase, no-underscore

# callee) used to fail to parse at all — `var_identifier` and `fn_identifier`

# both matched its text and the grammar's lexer would nondeterministically

# commit to `var_identifier`, breaking every such call site.

fun double(n: Int) -> Int =

  n * 2

enum GenericBox[T] =

  | GenericBox(value: T)

  fun getIntValue() -> Int =

    self.value

fun useGenericBox() -> Int =

  b := GenericBox(value: 7)

  b.getIntValue()

fun identity(value: T) -> T =

  value

enum GenericBox2[T] =

  | GenericBox2(value: T)

  fun getValue() -> Int =

    self.value

fun doubled(value: T) -> Int =

  identity(value) + identity(value)

enum FnOption[T] =

  | FnSome(T)

  | FnNone

fun unwrapFnOptionOr(o: FnOption, default: Int) -> Int =

  match o

    FnSome(v) => v

    FnNone => default

# `Str.length()` is not a real, working method — the point of this test is

# that `FnOption$Str` coexists with `FnOption$Int` and both run correctly, not

# string processing, so the Str arm returns a fixed literal.

fun unwrapFnOptionIntOr(o: FnOption, default: Int) -> Int =

  match o

    FnSome(v) => v

    FnNone => default

fun unwrapFnOptionStrOr(o: FnOption, default: Int) -> Int =

  match o

    FnSome(v) => 4

    FnNone => default

enum GenericBox3[T] =

  | GenericBox3(value: T)

  fun getBoxValue() -> Int =

    self.value

fun sumBox(b: GenericBox3) -> Int =

  b.getBoxValue()

fun combineVariadic(prefix: Int, rest: ...Int) -> Int =

  prefix

test "factorial runs correctly"

  assert factorial(5) == 120

test "lowercase single word function call runs correctly"

  assert double(21) == 42

test "generic class specialized at two types does not alias"

  assert useGenericBox() == 7

test "generic function called at multiple concrete types runs correctly"

  assert identity(5) + identity(37) == 42

test "generic method on generic class runs correctly"

  b := GenericBox2(value: 9)

  assert b.getValue() == 9

test "transitively generic call chain runs correctly"

  assert doubled(21) == 42

test "generic enum specialized and matched runs correctly"

  assert unwrapFnOptionOr(FnSome(13), 0) == 13

test "generic enum multiple instantiations coexist and run correctly"

  assert unwrapFnOptionIntOr(FnSome(13), 0) + unwrapFnOptionStrOr(FnSome("abcd"), 0) == 17

test "same bare generic enum param function called multiple times runs correctly"

  assert unwrapFnOptionOr(FnSome(5), 0) + unwrapFnOptionOr(FnSome(37), 0) == 42

test "ordinary function with bare generic class param runs correctly"

  assert sumBox(GenericBox3(value: 11)) == 11

test "variadic call with varying trailing arg counts runs correctly"

  a := combineVariadic(10)

  b := combineVariadic(20, 1)

  c := combineVariadic(30, 1, 2, 3)

  assert a + b + c == 60

test "sum all variadic int runs correctly"

  assert sumAll(1, 2, 3, 4) == 10

test "sum all variadic int with zero args runs correctly"

  assert sumAll() == 0