let xs = [1, 2, 3]

assert_eq(len([]), 0)
assert_eq(len(xs), 3)

assert_eq(head(xs), 1)
assert_eq(head(tail(xs)), 2)

assert_eq(tail(xs), [2, 3])

assert_eq(cons(0, xs), [0, 1, 2, 3])

assert_eq(cons_end(4, xs), [1, 2, 3, 4])
assert_eq(cons_end(0, []), [0])

assert(is_empty([]))
assert(!is_empty(xs))

assert_eq(concat([], []), [])
assert_eq(concat([], xs), xs)
assert_eq(concat(xs, []), xs)
assert_eq(concat(xs, xs), [1, 2, 3, 1, 2, 3])

assert_eq(take(0, xs), [])
assert_eq(take(1, xs), [1])
assert_eq(take(2, xs), [1, 2])
assert_eq(take(3, xs), [1, 2, 3])
assert_eq(take(4, xs), [1, 2, 3])
assert_eq(take(0, []), [])

assert_eq(drop(0, xs), [1, 2, 3])
assert_eq(drop(1, xs), [2, 3])
assert_eq(drop(2, xs), [3])
assert_eq(drop(3, xs), [])
assert_eq(drop(4, xs), [])
assert_eq(drop(0, []), [])

assert_eq(range(0, 0), [0])
assert_eq(range(0, 5), [0, 1, 2, 3, 4, 5])

assert_eq(reverse([]), [])
assert_eq(reverse(xs), [3, 2, 1])

fn inc(x) = x + 1
assert_eq(map(inc, xs), [2, 3, 4])

fn is_even(x) = mod(x, 2) == 0
assert_eq(filter(is_even, range(1, 10)), [2, 4, 6, 8, 10])

fn mul(x, y) = x * y
assert_eq(foldl(mul, 1, [1, 2, 3, 4, 5]), 120)

# sort:
assert_eq(sort([]), [])

assert_eq(sort([1]), [1])

assert_eq(sort([1, 2]), [1, 2])
assert_eq(sort([2, 1]), [1, 2])

assert_eq(sort([1, 2, 3]), [1, 2, 3])
assert_eq(sort([1, 3, 2]), [1, 2, 3])
assert_eq(sort([2, 1, 3]), [1, 2, 3])
assert_eq(sort([2, 3, 1]), [1, 2, 3])
assert_eq(sort([3, 1, 2]), [1, 2, 3])
assert_eq(sort([3, 2, 1]), [1, 2, 3])

# sort_by_key:
fn negate(x) = -x
assert_eq(sort_by_key(negate, [1, 2, 3]), [3, 2, 1])
assert_eq(sort_by_key(str_length, ["aa", "", "aaaa", "aaa"]), ["", "aa", "aaa", "aaaa"])

# contains:
assert(contains(1, [1]))

assert(contains(1, [1, 2, 3]))
assert(contains(1, [3, 2, 1]))
assert(contains(1, [3, 1, 2]))

assert(!contains(10, [1, 2, 3]))

assert(contains("1", ["1", "2", "3"]))

# unique:
assert_eq(unique([]), [])

assert_eq(unique([1, 2, 3]), [1, 2, 3])

assert_eq(unique([1, 2, 2, 3, 3, 3]), [1, 2, 3])
assert_eq(unique([3, 3, 3, 2, 2, 1]), [3, 2, 1])
assert_eq(unique([1, 3, 2, 3, 2, 3]), [1, 3, 2])

assert_eq(unique([1, 3, 2, 3, 2, 3]), unique(unique([1, 3, 2, 3, 2, 3,])))

# intersperse:
assert_eq(intersperse(0, []), [])
assert_eq(intersperse(0, [1]), [1])
assert_eq(intersperse(0, [1, 2, 3]), [1, 0, 2, 0, 3])

assert_eq(sum([1, 2, 3, 4, 5]), 15)
assert_eq(sum([1 m, 200 cm, 3 m]), 6 m)

assert_eq(linspace(0, 1, 2), [0, 1])
assert_eq(linspace(0, 1, 5), [0, 0.25, 0.5, 0.75, 1])
assert_eq(linspace(0, 2 m, 5), [0 m, 0.5 m, 1 m, 1.5 m, 2 m])

assert_eq(split("", ","), [])
assert_eq(split("a", ","), ["a"])
assert_eq(split("a,b,c", ","), ["a", "b", "c"])
assert_eq(split("foo,bar,baz", ","), ["foo", "bar", "baz"])

assert_eq(join([], ","), "")
assert_eq(join(["a"], ","), "a")
assert_eq(join(["a", "b", "c"], ","), "a,b,c")
assert_eq(join(["foo", "bar", "baz"], ","), "foo,bar,baz")

# Non-dtype lists
let words = ["hello", "world"]
assert_eq(head(words), "hello")

fn gen_range(n) = range(1, n)
assert_eq(map(gen_range, xs), [[1], [1, 2], [1, 2, 3]])
fn to_string(x) = "{x}"
assert_eq(map(to_string, xs), ["1", "2", "3"])