fun fact: u64 x -> u64
    if x = 0 then 1
    else x * fact (x-1)

fact 5  //=> 120

fun dotproduct: Arr i32 v1, Arr i32 v2 -> i64 where len v1 = len v2
    mut ret = 0
    for i in indices v1 do
        ret += v1#i * v2#i
    ret

dotproduct [1, 2, 3] [4, 5, 6]   //=> 22
dotproduct [1, 2, 3] [4, 5]      //error, lengths aren't equal!

//A collection of elements of type 'e
trait Collection 'e 'c
    fun push: 'c 'e col, 'e elem -> 'c 'e ret where len ret = len col + 1
    fun len: 'c 'e col -> usz
    fun get: 'c 'e col, usz idx -> 'e where idx < len col

trait Show 't
    fun to_string: 't obj -> Str

//print_elem : (Collection Show) 'c col, usz i -> Str where i < len col
fun print_elem: c, i =
    get c i |> to_string |> print

//build system is implemented as a library
//with no syntax changes to the language itself
import Build, File

default_target "program"

target "program" =
    depend_on "legacy_cpp"
    compile "driver.an"

target "legacy_cpp" =
    let cppfiles = glob "*.cpp"
    map cppfiles cxx
    link_with cppfiles

//print every line in the file
mut file = InFile "file.txt"
for line in file do
    print line

//or
map file print

//reading an integer from a stdin:
let n = read i32

//Or read directly from an xml-formatted file: 
let n = file.read i32 "<value>{}</value>"

//in file.hpp
struct Triple {
    int first, second, third;

    Triple(int a, int b, int c) :
        first(a), second(b), third(c){}

    int firstPlus(int d) const {
        return first + d;
    }
}; //in driver.an
//call clang api to parse file and import functions
import Cpp "file.hpp"
let t = Triple(1, 2, 3)
t.firstPlus t.third  //=> 4

//Extend type system to support lazy types with !lazy
fun when: Comparison cond, !lazy 't a b c
    match cond with
    | LessThan -> a
    | Equal -> b
    | GreaterThan -> c

let ans, guess = 42, 53

//only "too high!" is outputted
when (guess.compare ans) \
    (print "too low!")     \
    (print "just right!")  \
    (print "too high!")