diff --git a/.gitignore b/.gitignore index e9656d1..ea86051 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,6 @@ _site build build-ninja -*.comp -stats *.swp *.swm *.swn @@ -12,28 +10,6 @@ stats *.swj *.swk *.png -*krakout* -kraklist.txt .*.un~ -papers callgrind* -*.comp_new -*.comp_new.expr -*.comp_bac -bintest.bin -*.dot .stfolder -kraken -*.c -kraken_bac -kraken_deprecated -bootstrap_kalypso -kraken_bootstrap -compiler_version.krak -untracked_misc -k_prime - - -# Added by cargo - -/target diff --git a/fib_test/fib.c b/fib_test/fib.c new file mode 100644 index 0000000..7dd927b --- /dev/null +++ b/fib_test/fib.c @@ -0,0 +1,14 @@ + +int fib(n) { + if (n == 0) { + return 1; + } else if (n == 1) { + return 1; + } else { + return fib(n-1) + fib(n-2); + } +} +int main(int argc, char **argv) { + printf("%d\n", fib(atoi(argv[1]))); + return 0; +} diff --git a/fib_test/fib_let.c b/fib_test/fib_let.c new file mode 100644 index 0000000..85ef649 --- /dev/null +++ b/fib_test/fib_let.c @@ -0,0 +1,16 @@ + +int fib(n) { + if (n == 0) { + return 1; + } else if (n == 1) { + return 1; + } else { + int r1 = fib(n-1); + int r2 = fib(n-2); + return r1 + r2; + } +} +int main(int argc, char **argv) { + printf("%d\n", fib(atoi(argv[1]))); + return 0; +} diff --git a/koka_bench/kraken/CMakeLists.txt b/koka_bench/kraken/CMakeLists.txt new file mode 100644 index 0000000..81f65fe --- /dev/null +++ b/koka_bench/kraken/CMakeLists.txt @@ -0,0 +1,22 @@ +set(sources rbtree.kp rbtree-opt.kp nqueens.kp cfold.kp deriv.kp) + +set(kraken "../../kraken_wrapper.sh") + + +foreach (source IN LISTS sources) + get_filename_component(basename "${source}" NAME_WE) + set(name "kraken-${basename}") + + set(out_dir "${CMAKE_CURRENT_BINARY_DIR}/out/bench") + set(out_path "${out_dir}/${name}") + + add_custom_command( + OUTPUT ${out_path} + COMMAND ${kraken} "${CMAKE_CURRENT_SOURCE_DIR}/${source}" ${out_dir} ${name} + DEPENDS ${source} + VERBATIM) + + add_custom_target(update-${name} ALL DEPENDS "${out_path}") + add_executable(${name}-exe IMPORTED) + set_target_properties(${name}-exe PROPERTIES IMPORTED_LOCATION "${out_path}") +endforeach () diff --git a/koka_bench/kraken/cfold.kp b/koka_bench/kraken/cfold.kp new file mode 100644 index 0000000..526e15b --- /dev/null +++ b/koka_bench/kraken/cfold.kp @@ -0,0 +1,244 @@ +((wrap (vau root_env (quote) +((wrap (vau (let1) +(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se))) +(let1 current-env (vau de () de) +(let1 cons (lambda (h t) (concat (array h) t)) +(let1 Y (lambda (f3) + ((lambda (x1) (x1 x1)) + (lambda (x2) (f3 (wrap (vau app_env (& y) (lapply (x2 x2) y app_env))))))) +(let1 vY (lambda (f) + ((lambda (x3) (x3 x3)) + (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1)))))) +(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2) + true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2))))) + (let ( + lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args))))) + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + if (vau de (con than & else) (eval (array cond con than + true (cond (> (len else) 0) (idx else 0) + true false)) de)) + + map (lambda (f5 l5) + (let (helper (rec-lambda recurse (f4 l4 n4 i4) + (cond (= i4 (len l4)) n4 + (<= i4 (- (len l4) 4)) (recurse f4 l4 (concat n4 (array + (f4 (idx l4 (+ i4 0))) + (f4 (idx l4 (+ i4 1))) + (f4 (idx l4 (+ i4 2))) + (f4 (idx l4 (+ i4 3))) + )) (+ i4 4)) + true (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1))))) + (helper f5 l5 (array) 0))) + + + map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (cond (= i (len l)) n + (<= i (- (len l) 4)) (recurse f l (concat n (array + (f (+ i 0) (idx l (+ i 0))) + (f (+ i 1) (idx l (+ i 1))) + (f (+ i 2) (idx l (+ i 2))) + (f (+ i 3) (idx l (+ i 3))) + )) (+ i 4)) + true (recurse f l (concat n (array (f i (idx l i)))) (+ i 1))))) + (helper f l (array) 0))) + + filter_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (if (f i (idx l i)) (recurse f l (concat n (array (idx l i))) (+ i 1)) + (recurse f l n (+ i 1)))))) + (helper f l (array) 0))) + filter (lambda (f l) (filter_i (lambda (i x) (f x)) l)) + + ; Huge thanks to Oleg Kiselyov for his fantastic website + ; http://okmij.org/ftp/Computation/fixed-point-combinators.html + Y* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (lambda (& x) (lapply (lapply li (p p)) x))) l)))) + vY* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (vau ide (& x) (vapply (lapply li (p p)) x ide))) l)))) + + let-rec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array Y*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + let-vrec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array vY*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + + flat_map (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + flat_map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f i (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + + ; with all this, we make a destrucutring-capable let + let (let ( + destructure_helper (rec-lambda recurse (vs i r) + (cond (= (len vs) i) r + (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i))) + new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i)) + ) + (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1)))))) + true (recurse vs (+ i 2) (concat r (slice vs i (+ i 2)))) + ))) (vau de (vs b) (vapply let (array (destructure_helper vs 0 (array)) b) de))) + + ; and a destructuring-capable lambda! + only_symbols (rec-lambda recurse (a i) (cond (= i (len a)) true + (symbol? (idx a i)) (recurse a (+ i 1)) + true false)) + + ; Note that if macro_helper is inlined, the mapping lambdas will close over + ; se, and then not be able to be taken in as values to the maps, and the vau + ; will fail to partially evaluate away. + lambda (let (macro_helper (lambda (p b) (let ( + sym_params (map (lambda (param) (if (symbol? param) param + (str-to-symbol (str param)))) p) + body (array let (flat_map_i (lambda (i x) (array (idx p i) x)) sym_params) b) + ) (array vau sym_params body)))) + (vau se (p b) (if (only_symbols p 0) (vapply lambda (array p b) se) + (wrap (eval (macro_helper p b) se))))) + + ; and rec-lambda - yes it's the same definition again + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + + nil (array) + not (lambda (x) (if x false true)) + or (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) false + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp 'tmp (recurse bs (+ i 1))))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) true + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + + + + foldl (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (recurse f (lapply f (cons z (map (lambda (x) (idx x i)) vs))) vs (+ i 1))))) + (lambda (f z & vs) (helper f z vs 0))) + foldr (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (lapply f (cons (recurse f z vs (+ i 1)) (map (lambda (x) (idx x i)) vs)))))) + (lambda (f z & vs) (helper f z vs 0))) + reverse (lambda (x) (foldl (lambda (acc i) (cons i acc)) (array) x)) + zip (lambda (& xs) (lapply foldr (concat (array (lambda (a & ys) (cons ys a)) (array)) xs))) + + match (let ( + evaluate_case (rec-lambda evaluate_case (access c) (cond + (symbol? c) (array true (lambda (b) (array let (array c access) b))) + (and (array? c) (= 2 (len c)) (= 'unquote (idx c 0))) (array (array = access (idx c 1)) (lambda (b) b)) + (and (array? c) (= 2 (len c)) (= 'quote (idx c 0))) (array (array = access c) (lambda (b) b)) + (array? c) (let ( + tests (array and (array array? access) (array = (len c) (array len access))) + (tests body_func) ((rec-lambda recurse (tests body_func i) (if (= i (len c)) + (array tests body_func) + (let ( (inner_test inner_body_func) (evaluate_case (array idx access i) (idx c i)) ) + (recurse (concat tests (array inner_test)) + (lambda (b) (body_func (inner_body_func b))) + (+ i 1))))) + tests (lambda (b) b) 0) + ) (array tests body_func)) + true (array (array = access c) (lambda (b) b)) + )) + helper (rec-lambda helper (x_sym cases i) (cond (< i (- (len cases) 1)) (let ( (test body_func) (evaluate_case x_sym (idx cases i)) ) + (concat (array test (body_func (idx cases (+ i 1)))) (helper x_sym cases (+ i 2)))) + true (array true (array error "none matched")))) + ) (vau de (x & cases) (eval (array let (array '___MATCH_SYM x) (concat (array cond) (helper '___MATCH_SYM cases 0))) de))) + + + Var (lambda (x) (array 'Var x)) + Val (lambda (x) (array 'Val x)) + Add (lambda (l r) (array 'Add l r)) + Mul (lambda (l r) (array 'Mul l r)) + + max (lambda (a b) (if (> a b) a b)) + + mk_expr (rec-lambda mk_expr (n v) + (if (= n 0) + (if (= v 0) (Var 1) (Val v)) + (Add (mk_expr (- n 1) (+ v 1)) (mk_expr (- n 1) (max (- v 1) 0))))) + + append_add (rec-lambda append_add (e0 e3) (match e0 + ('Add e1 e2) (Add e1 (append_add e2 e3)) + _ (Add e0 e3) + )) + + append_mul (rec-lambda append_mul (e0 e3) (match e0 + ('Mul e1 e2) (Mul e1 (append_mul e2 e3)) + _ (Mul e0 e3) + )) + + reassoc (rec-lambda reassoc (e) (match e + ('Add e1 e2) (append_add (reassoc e1) (reassoc e2)) + ('Mul e1 e2) (append_mul (reassoc e1) (reassoc e2)) + x x + )) + + cfold (rec-lambda cfold (e) (match e + ('Add l r) (let (lp (cfold l) + rp (cfold r)) + (match lp + ('Val lpv) (match rp + ('Val rpv) (Val (+ lpv rpv)) + ('Add f ('Val b)) (Add (Val (+ lpv b)) f) + ('Add ('Val b) f) (Add (Val (+ lpv b)) f) + rpo (Add lp rpo)) + lpo (Add lpo rp))) + ('Mul l r) (let (lp (cfold l) + rp (cfold r)) + (match lp + ('Val lpv) (match rp + ('Val rpv) (Val (* lpv rpv)) + ('Mul f ('Val b)) (Mul (Val (* lpv b)) f) + ('Mul ('Val b) f) (Mul (Val (* lpv b)) f) + rpo (Mul lp rpo)) + lpo (Mul lpo rp))) + x x + )) + + eval (rec-lambda eval (e) (match e + ('Var x) 0 + ('Val v) v + ('Add l r) (+ (eval l) (eval r)) + ('Mul l r) (* (eval l) (eval r)) + )) + + monad (array 'write 1 (str "running cfold") (vau (written code) + (array 'args (vau (args code) + (array 'exit (let ( + e (mk_expr (read-string (idx args 1)) 1) + v1 (eval e) + v2 (eval (cfold (reassoc e))) + _ (log v1) + _ (log v2) + ) 0)) + )) + )) + + ) monad) +; end of all lets +)))))) +; impl of let1 +)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de))) +; impl of quote +)) (vau (x5) x5)) diff --git a/koka_bench/kraken/csc_out.wasm b/koka_bench/kraken/csc_out.wasm new file mode 100644 index 0000000..c4b06fb Binary files /dev/null and b/koka_bench/kraken/csc_out.wasm differ diff --git a/koka_bench/kraken/deriv.kp b/koka_bench/kraken/deriv.kp new file mode 100644 index 0000000..f6e6c29 --- /dev/null +++ b/koka_bench/kraken/deriv.kp @@ -0,0 +1,263 @@ +((wrap (vau root_env (quote) +((wrap (vau (let1) +(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se))) +(let1 current-env (vau de () de) +(let1 cons (lambda (h t) (concat (array h) t)) +(let1 Y (lambda (f3) + ((lambda (x1) (x1 x1)) + (lambda (x2) (f3 (wrap (vau app_env (& y) (lapply (x2 x2) y app_env))))))) +(let1 vY (lambda (f) + ((lambda (x3) (x3 x3)) + (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1)))))) +(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2) + true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2))))) + (let ( + lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args))))) + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + if (vau de (con than & else) (eval (array cond con than + true (cond (> (len else) 0) (idx else 0) + true false)) de)) + + map (lambda (f5 l5) + (let (helper (rec-lambda recurse (f4 l4 n4 i4) + (cond (= i4 (len l4)) n4 + (<= i4 (- (len l4) 4)) (recurse f4 l4 (concat n4 (array + (f4 (idx l4 (+ i4 0))) + (f4 (idx l4 (+ i4 1))) + (f4 (idx l4 (+ i4 2))) + (f4 (idx l4 (+ i4 3))) + )) (+ i4 4)) + true (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1))))) + (helper f5 l5 (array) 0))) + + + map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (cond (= i (len l)) n + (<= i (- (len l) 4)) (recurse f l (concat n (array + (f (+ i 0) (idx l (+ i 0))) + (f (+ i 1) (idx l (+ i 1))) + (f (+ i 2) (idx l (+ i 2))) + (f (+ i 3) (idx l (+ i 3))) + )) (+ i 4)) + true (recurse f l (concat n (array (f i (idx l i)))) (+ i 1))))) + (helper f l (array) 0))) + + filter_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (if (f i (idx l i)) (recurse f l (concat n (array (idx l i))) (+ i 1)) + (recurse f l n (+ i 1)))))) + (helper f l (array) 0))) + filter (lambda (f l) (filter_i (lambda (i x) (f x)) l)) + + ; Huge thanks to Oleg Kiselyov for his fantastic website + ; http://okmij.org/ftp/Computation/fixed-point-combinators.html + Y* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (lambda (& x) (lapply (lapply li (p p)) x))) l)))) + vY* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (vau ide (& x) (vapply (lapply li (p p)) x ide))) l)))) + + let-rec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array Y*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + let-vrec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array vY*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + + flat_map (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + flat_map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f i (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + + ; with all this, we make a destrucutring-capable let + let (let ( + destructure_helper (rec-lambda recurse (vs i r) + (cond (= (len vs) i) r + (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i))) + new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i)) + ) + (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1)))))) + true (recurse vs (+ i 2) (concat r (slice vs i (+ i 2)))) + ))) (vau de (vs b) (vapply let (array (destructure_helper vs 0 (array)) b) de))) + + ; and a destructuring-capable lambda! + only_symbols (rec-lambda recurse (a i) (cond (= i (len a)) true + (symbol? (idx a i)) (recurse a (+ i 1)) + true false)) + + ; Note that if macro_helper is inlined, the mapping lambdas will close over + ; se, and then not be able to be taken in as values to the maps, and the vau + ; will fail to partially evaluate away. + lambda (let (macro_helper (lambda (p b) (let ( + sym_params (map (lambda (param) (if (symbol? param) param + (str-to-symbol (str param)))) p) + body (array let (flat_map_i (lambda (i x) (array (idx p i) x)) sym_params) b) + ) (array vau sym_params body)))) + (vau se (p b) (if (only_symbols p 0) (vapply lambda (array p b) se) + (wrap (eval (macro_helper p b) se))))) + + ; and rec-lambda - yes it's the same definition again + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + + nil (array) + not (lambda (x) (if x false true)) + or (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) false + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp 'tmp (recurse bs (+ i 1))))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) true + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + + + + foldl (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (recurse f (lapply f (cons z (map (lambda (x) (idx x i)) vs))) vs (+ i 1))))) + (lambda (f z & vs) (helper f z vs 0))) + foldr (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (lapply f (cons (recurse f z vs (+ i 1)) (map (lambda (x) (idx x i)) vs)))))) + (lambda (f z & vs) (helper f z vs 0))) + reverse (lambda (x) (foldl (lambda (acc i) (cons i acc)) (array) x)) + zip (lambda (& xs) (lapply foldr (concat (array (lambda (a & ys) (cons ys a)) (array)) xs))) + + match (let ( + evaluate_case (rec-lambda evaluate_case (access c) (cond + (symbol? c) (array true (lambda (b) (array let (array c access) b))) + (and (array? c) (= 2 (len c)) (= 'unquote (idx c 0))) (array (array = access (idx c 1)) (lambda (b) b)) + (and (array? c) (= 2 (len c)) (= 'quote (idx c 0))) (array (array = access c) (lambda (b) b)) + (array? c) (let ( + tests (array and (array array? access) (array = (len c) (array len access))) + (tests body_func) ((rec-lambda recurse (tests body_func i) (if (= i (len c)) + (array tests body_func) + (let ( (inner_test inner_body_func) (evaluate_case (array idx access i) (idx c i)) ) + (recurse (concat tests (array inner_test)) + (lambda (b) (body_func (inner_body_func b))) + (+ i 1))))) + tests (lambda (b) b) 0) + ) (array tests body_func)) + true (array (array = access c) (lambda (b) b)) + )) + helper (rec-lambda helper (x_sym cases i) (cond (< i (- (len cases) 1)) (let ( (test body_func) (evaluate_case x_sym (idx cases i)) ) + (concat (array test (body_func (idx cases (+ i 1)))) (helper x_sym cases (+ i 2)))) + true (array true (array error "none matched")))) + ) (vau de (x & cases) (eval (array let (array '___MATCH_SYM x) (concat (array cond) (helper '___MATCH_SYM cases 0))) de))) + + + Var (lambda (x) (array 'Var x)) + Val (lambda (x) (array 'Val x)) + Add (lambda (l r) (array 'Add l r)) + Mul (lambda (l r) (array 'Mul l r)) + Pow (lambda (l r) (array 'Pow l r)) + Ln (lambda (e) (array 'Ln e)) + + pown_helper (rec-lambda pown_helper (a b acc) (if (= b 0) acc + (pown_helper a (- b 1) (* a acc)))) + pown (lambda (a b) (pown_helper a b 1)) + + add (rec-lambda add (n0 m0) (match (array n0 m0) + (('Val n) ('Val m)) (Val (+ n m)) + (('Val 0) f) f + (f ('Val 0)) f + (f ('Val n)) (add (Val n) f) + (('Val n) ('Add ('Val m) f)) (add (Val (+ n m)) f) + (f ('Add ('Val n) g)) (add (Val n) (add f g)) + (('Add f g) h) (add f (add g h)) + (f g) (Add f g) + )) + + mul (rec-lambda mul (n0 m0) (match (array n0 m0) + (('Val n) ('Val m)) (Val (* n m)) + (('Val 0) _) (Val 0) + (_ ('Val 0)) (Val 0) + (f ('Val 1)) f + (('Val 1) f) f + + (f ('Val n)) (mul (Val n) f) + (('Val n) ('Mul ('Val m) f)) (mul (Val (* n m)) f) + (f ('Mul ('Val n) g)) (mul (Val n) (mul f g)) + (('Mul f g) h) (mul f (mul g h)) + (f g) (Mul f g) + )) + + powr (lambda (m0 n0) (match (array m0 n0) + (('Val m) ('Val n)) (Val (pown m n)) + (_ ('Val 0)) (Val 1) + (f ('Val 1)) f + (('Val 0) _) (Val 0) + (f g) (Pow f g) + )) + + ln (lambda (n) (match n + ('Val 1) (Val 0) + f (Ln f) + )) + + d (rec-lambda d (x e) (match e + ('Val _) (Val 0) + ('Var y) (if (= x y) (Val 1) (Val 0)) + ('Add f g) (add (d x f) (d x g)) + ('Mul f g) (add (mul f (d x g)) (mul g (d x f))) + ('Pow f g) (mul (powr f g) (add (mul (mul g (d x f)) (powr f (Val -1))) (mul (ln f) (d x g)))) + ('Ln f) (mul (d x f) (powr f (Val -1))) + )) + + count (rec-lambda count (e) (match e + ('Val _) 1 + ('Var y) 1 + ('Add f g) (+ (count f) (count g)) + ('Mul f g) (+ (count f) (count g)) + ('Pow f g) (+ (count f) (count g)) + ('Ln f) (count f) + )) + + nest_aux (rec-lambda nest_aux (s f n x) (if (= n 0) x + (nest_aux s f (- n 1) (f (- s n) x)))) + nest (lambda (f n e) (nest_aux n f n e)) + + deriv (lambda (i f) (let (d (d "x" f) + _ (log (+ i 1) " count: " (count d)) + ) d)) + + + monad (array 'write 1 (str "running deriv") (vau (written code) + (array 'args (vau (args code) + (array 'exit (let ( + n (read-string (idx args 1)) + x (Var "x") + f (powr x x) + _ (log (nest deriv n f)) + _ (log "done") + ) 0)) + )) + )) + + ) monad) +; end of all lets +)))))) +; impl of let1 +)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de))) +; impl of quote +)) (vau (x5) x5)) diff --git a/koka_bench/kraken/nqueens.kp b/koka_bench/kraken/nqueens.kp new file mode 100644 index 0000000..f3fd382 --- /dev/null +++ b/koka_bench/kraken/nqueens.kp @@ -0,0 +1,210 @@ +((wrap (vau root_env (quote) +((wrap (vau (let1) +(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se))) +(let1 current-env (vau de () de) +(let1 cons (lambda (h t) (concat (array h) t)) +(let1 Y (lambda (f3) + ((lambda (x1) (x1 x1)) + (lambda (x2) (f3 (wrap (vau app_env (& y) (lapply (x2 x2) y app_env))))))) +(let1 vY (lambda (f) + ((lambda (x3) (x3 x3)) + (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1)))))) +(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2) + true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2))))) + (let ( + lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args))))) + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + if (vau de (con than & else) (eval (array cond con than + true (cond (> (len else) 0) (idx else 0) + true false)) de)) + + map (lambda (f5 l5) + (let (helper (rec-lambda recurse (f4 l4 n4 i4) + (cond (= i4 (len l4)) n4 + (<= i4 (- (len l4) 4)) (recurse f4 l4 (concat n4 (array + (f4 (idx l4 (+ i4 0))) + (f4 (idx l4 (+ i4 1))) + (f4 (idx l4 (+ i4 2))) + (f4 (idx l4 (+ i4 3))) + )) (+ i4 4)) + true (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1))))) + (helper f5 l5 (array) 0))) + + + map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (cond (= i (len l)) n + (<= i (- (len l) 4)) (recurse f l (concat n (array + (f (+ i 0) (idx l (+ i 0))) + (f (+ i 1) (idx l (+ i 1))) + (f (+ i 2) (idx l (+ i 2))) + (f (+ i 3) (idx l (+ i 3))) + )) (+ i 4)) + true (recurse f l (concat n (array (f i (idx l i)))) (+ i 1))))) + (helper f l (array) 0))) + + filter_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (if (f i (idx l i)) (recurse f l (concat n (array (idx l i))) (+ i 1)) + (recurse f l n (+ i 1)))))) + (helper f l (array) 0))) + filter (lambda (f l) (filter_i (lambda (i x) (f x)) l)) + + ; Huge thanks to Oleg Kiselyov for his fantastic website + ; http://okmij.org/ftp/Computation/fixed-point-combinators.html + Y* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (lambda (& x) (lapply (lapply li (p p)) x))) l)))) + vY* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (vau ide (& x) (vapply (lapply li (p p)) x ide))) l)))) + + let-rec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array Y*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + let-vrec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array vY*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + + flat_map (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + flat_map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f i (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + + ; with all this, we make a destrucutring-capable let + let (let ( + destructure_helper (rec-lambda recurse (vs i r) + (cond (= (len vs) i) r + (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i))) + new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i)) + ) + (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1)))))) + true (recurse vs (+ i 2) (concat r (slice vs i (+ i 2)))) + ))) (vau de (vs b) (vapply let (array (destructure_helper vs 0 (array)) b) de))) + + ; and a destructuring-capable lambda! + only_symbols (rec-lambda recurse (a i) (cond (= i (len a)) true + (symbol? (idx a i)) (recurse a (+ i 1)) + true false)) + + ; Note that if macro_helper is inlined, the mapping lambdas will close over + ; se, and then not be able to be taken in as values to the maps, and the vau + ; will fail to partially evaluate away. + lambda (let (macro_helper (lambda (p b) (let ( + sym_params (map (lambda (param) (if (symbol? param) param + (str-to-symbol (str param)))) p) + body (array let (flat_map_i (lambda (i x) (array (idx p i) x)) sym_params) b) + ) (array vau sym_params body)))) + (vau se (p b) (if (only_symbols p 0) (vapply lambda (array p b) se) + (wrap (eval (macro_helper p b) se))))) + + ; and rec-lambda - yes it's the same definition again + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + + nil (array) + not (lambda (x) (if x false true)) + or (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) false + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp 'tmp (recurse bs (+ i 1))))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) true + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + + + + foldl (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (recurse f (lapply f (cons z (map (lambda (x) (idx x i)) vs))) vs (+ i 1))))) + (lambda (f z & vs) (helper f z vs 0))) + foldr (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (lapply f (cons (recurse f z vs (+ i 1)) (map (lambda (x) (idx x i)) vs)))))) + (lambda (f z & vs) (helper f z vs 0))) + reverse (lambda (x) (foldl (lambda (acc i) (cons i acc)) (array) x)) + zip (lambda (& xs) (lapply foldr (concat (array (lambda (a & ys) (cons ys a)) (array)) xs))) + + match (let ( + evaluate_case (rec-lambda evaluate_case (access c) (cond + (symbol? c) (array true (lambda (b) (array let (array c access) b))) + (and (array? c) (= 2 (len c)) (= 'unquote (idx c 0))) (array (array = access (idx c 1)) (lambda (b) b)) + (and (array? c) (= 2 (len c)) (= 'quote (idx c 0))) (array (array = access c) (lambda (b) b)) + (array? c) (let ( + tests (array and (array array? access) (array = (len c) (array len access))) + (tests body_func) ((rec-lambda recurse (tests body_func i) (if (= i (len c)) + (array tests body_func) + (let ( (inner_test inner_body_func) (evaluate_case (array idx access i) (idx c i)) ) + (recurse (concat tests (array inner_test)) + (lambda (b) (body_func (inner_body_func b))) + (+ i 1))))) + tests (lambda (b) b) 0) + ) (array tests body_func)) + true (array (array = access c) (lambda (b) b)) + )) + helper (rec-lambda helper (x_sym cases i) (cond (< i (- (len cases) 1)) (let ( (test body_func) (evaluate_case x_sym (idx cases i)) ) + (concat (array test (body_func (idx cases (+ i 1)))) (helper x_sym cases (+ i 2)))) + true (array true (array error "none matched")))) + ) (vau de (x & cases) (eval (array let (array '___MATCH_SYM x) (concat (array cond) (helper '___MATCH_SYM cases 0))) de))) + + + safe (rec-lambda safe (queen diag i xs) + (if (= i (len xs)) + true + (let ( q (idx xs i) ) + (and (!= queen q) + (!= queen (+ q diag)) + (!= queen (- q diag)) + (safe queen (+ diag 1) (+ i 1) xs))))) + append-safe (rec-lambda append-safe (queen xs xss) + (cond (<= queen 0) xss + (safe queen 1 0 xs) (append-safe (- queen 1) + xs + (cons (cons queen xs) xss)) + true (append-safe (- queen 1) xs xss))) + extend (rec-lambda extend (queen acc xss i) + (if (= i (len xss)) + acc + (extend queen + (append-safe queen (idx xss i) acc) + xss + (+ i 1)))) + + find-solutions (rec-lambda find-solutions (n queen) + (if (= 0 queen) + (array nil) + (extend n nil (find-solutions n (- queen 1)) 0))) + nqueens (lambda (n) (len (find-solutions n n))) + + + monad (array 'write 1 (str "running nqueens") (vau (written code) + (array 'args (vau (args code) + (array 'exit (log (nqueens (read-string (idx args 1))))) + )) + )) + + ) monad) +; end of all lets +)))))) +; impl of let1 +)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de))) +; impl of quote +)) (vau (x5) x5)) diff --git a/koka_bench/kraken/rbtree-opt.kp b/koka_bench/kraken/rbtree-opt.kp new file mode 100644 index 0000000..90c79c3 --- /dev/null +++ b/koka_bench/kraken/rbtree-opt.kp @@ -0,0 +1,225 @@ +((wrap (vau root_env (quote) +((wrap (vau (let1) +(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se))) +(let1 current-env (vau de () de) +(let1 cons (lambda (h t) (concat (array h) t)) +(let1 Y (lambda (f3) + ((lambda (x1) (x1 x1)) + (lambda (x2) (f3 (wrap (vau app_env (& y) (lapply (x2 x2) y app_env))))))) +(let1 vY (lambda (f) + ((lambda (x3) (x3 x3)) + (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1)))))) +(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2) + true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2))))) + (let ( + lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args))))) + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + if (vau de (con than & else) (eval (array cond con than + true (cond (> (len else) 0) (idx else 0) + true false)) de)) + + map (lambda (f5 l5) + (let (helper (rec-lambda recurse (f4 l4 n4 i4) + (cond (= i4 (len l4)) n4 + (<= i4 (- (len l4) 4)) (recurse f4 l4 (concat n4 (array + (f4 (idx l4 (+ i4 0))) + (f4 (idx l4 (+ i4 1))) + (f4 (idx l4 (+ i4 2))) + (f4 (idx l4 (+ i4 3))) + )) (+ i4 4)) + true (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1))))) + (helper f5 l5 (array) 0))) + + + map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (cond (= i (len l)) n + (<= i (- (len l) 4)) (recurse f l (concat n (array + (f (+ i 0) (idx l (+ i 0))) + (f (+ i 1) (idx l (+ i 1))) + (f (+ i 2) (idx l (+ i 2))) + (f (+ i 3) (idx l (+ i 3))) + )) (+ i 4)) + true (recurse f l (concat n (array (f i (idx l i)))) (+ i 1))))) + (helper f l (array) 0))) + + filter_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (if (f i (idx l i)) (recurse f l (concat n (array (idx l i))) (+ i 1)) + (recurse f l n (+ i 1)))))) + (helper f l (array) 0))) + filter (lambda (f l) (filter_i (lambda (i x) (f x)) l)) + + ; Huge thanks to Oleg Kiselyov for his fantastic website + ; http://okmij.org/ftp/Computation/fixed-point-combinators.html + Y* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (lambda (& x) (lapply (lapply li (p p)) x))) l)))) + vY* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (vau ide (& x) (vapply (lapply li (p p)) x ide))) l)))) + + let-rec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array Y*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + let-vrec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array vY*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + + flat_map (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + flat_map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f i (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + + ; with all this, we make a destrucutring-capable let + let (let ( + destructure_helper (rec-lambda recurse (vs i r) + (cond (= (len vs) i) r + (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i))) + new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i)) + ) + (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1)))))) + true (recurse vs (+ i 2) (concat r (slice vs i (+ i 2)))) + ))) (vau de (vs b) (vapply let (array (destructure_helper vs 0 (array)) b) de))) + + ; and a destructuring-capable lambda! + only_symbols (rec-lambda recurse (a i) (cond (= i (len a)) true + (symbol? (idx a i)) (recurse a (+ i 1)) + true false)) + + ; Note that if macro_helper is inlined, the mapping lambdas will close over + ; se, and then not be able to be taken in as values to the maps, and the vau + ; will fail to partially evaluate away. + lambda (let (macro_helper (lambda (p b) (let ( + sym_params (map (lambda (param) (if (symbol? param) param + (str-to-symbol (str param)))) p) + body (array let (flat_map_i (lambda (i x) (array (idx p i) x)) sym_params) b) + ) (array vau sym_params body)))) + (vau se (p b) (if (only_symbols p 0) (vapply lambda (array p b) se) + (wrap (eval (macro_helper p b) se))))) + + ; and rec-lambda - yes it's the same definition again + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + + nil (array) + not (lambda (x) (if x false true)) + or (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) false + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp 'tmp (recurse bs (+ i 1))))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) true + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + + + + foldl (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (recurse f (lapply f (cons z (map (lambda (x) (idx x i)) vs))) vs (+ i 1))))) + (lambda (f z & vs) (helper f z vs 0))) + foldr (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (lapply f (cons (recurse f z vs (+ i 1)) (map (lambda (x) (idx x i)) vs)))))) + (lambda (f z & vs) (helper f z vs 0))) + reverse (lambda (x) (foldl (lambda (acc i) (cons i acc)) (array) x)) + zip (lambda (& xs) (lapply foldr (concat (array (lambda (a & ys) (cons ys a)) (array)) xs))) + + match (let ( + evaluate_case (rec-lambda evaluate_case (access c) (cond + (symbol? c) (array true (lambda (b) (array let (array c access) b))) + (and (array? c) (= 2 (len c)) (= 'unquote (idx c 0))) (array (array = access (idx c 1)) (lambda (b) b)) + (and (array? c) (= 2 (len c)) (= 'quote (idx c 0))) (array (array = access c) (lambda (b) b)) + (array? c) (let ( + tests (array and (array array? access) (array = (len c) (array len access))) + (tests body_func) ((rec-lambda recurse (tests body_func i) (if (= i (len c)) + (array tests body_func) + (let ( (inner_test inner_body_func) (evaluate_case (array idx access i) (idx c i)) ) + (recurse (concat tests (array inner_test)) + (lambda (b) (body_func (inner_body_func b))) + (+ i 1))))) + tests (lambda (b) b) 0) + ) (array tests body_func)) + true (array (array = access c) (lambda (b) b)) + )) + helper (rec-lambda helper (x_sym cases i) (cond (< i (- (len cases) 1)) (let ( (test body_func) (evaluate_case x_sym (idx cases i)) ) + (concat (array test (body_func (idx cases (+ i 1)))) (helper x_sym cases (+ i 2)))) + true (array true (array error "none matched")))) + ) (vau de (x & cases) (eval (array let (array '___MATCH_SYM x) (concat (array cond) (helper '___MATCH_SYM cases 0))) de))) + + ; This is based on https://www.cs.cornell.edu/courses/cs3110/2020sp/a4/deletion.pdf + ; and the figure references refer to it + ; Insert is taken from the same paper, but is origional to Okasaki, I belive + + ; The tree has been modified slightly to take in a comparison function + ; and override if insert replaces or not to allow use as a set or as a map + + ; I think this is actually pretty cool - instead of having a bunch of seperate ['B] + ; be our leaf node, we use ['B] with all nils. This allows us to not use -B, as + ; both leaf and non-leaf 'BB has the same structure with children! Also, we make + ; sure to use empty itself so we don't make a ton of empties... + empty (array 'B nil nil nil) + E empty + EE (array 'BB nil nil nil) + + generic-foldl (rec-lambda recurse (f z t) (match t + ,E z + (c a x b) (recurse f (f (recurse f z a) x) b))) + + blacken (lambda (t) (match t + ('R a x b) (array 'B a x b) + t t)) + balance (lambda (t) (match t + ; figures 1 and 2 + ('B ('R ('R a x b) y c) z d) (array 'R (array 'B a x b) y (array 'B c z d)) + ('B ('R a x ('R b y c)) z d) (array 'R (array 'B a x b) y (array 'B c z d)) + ('B a x ('R ('R b y c) z d)) (array 'R (array 'B a x b) y (array 'B c z d)) + ('B a x ('R b y ('R c z d))) (array 'R (array 'B a x b) y (array 'B c z d)) + ; figure 8, double black cases + ('BB ('R a x ('R b y c)) z d) (array 'B (array 'B a x b) y (array 'B c z d)) + ('BB a x ('R ('R b y c) z d)) (array 'B (array 'B a x b) y (array 'B c z d)) + ; already balenced + t t)) + map-insert (lambda (t k v) (blacken ((rec-lambda ins (t) (match t + ,E (array 'R t (array k v) t) + (c a x b) (cond (< k (idx x 0)) (balance (array c (ins a) x b)) + (= k (idx x 0)) (array c a (array k v) b) + true (balance (array c a x (ins b)))))) t))) + + map-empty empty + + make-test-tree (rec-lambda make-test-tree (n t) (cond (<= n 0) t + true (make-test-tree (- n 1) (map-insert t n (= 0 (% n 10)))))) + reduce-test-tree (lambda (tree) (generic-foldl (lambda (a x) (if (idx x 1) (+ a 1) a)) 0 tree)) + + monad (array 'write 1 (str "running tree test") (vau (written code) + (array 'args (vau (args code) + (array 'exit (log (reduce-test-tree (make-test-tree (read-string (idx args 1)) map-empty)))) + )) + )) + + ) monad) +; end of all lets +)))))) +; impl of let1 +)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de))) +; impl of quote +)) (vau (x5) x5)) diff --git a/koka_bench/kraken/rbtree.kp b/koka_bench/kraken/rbtree.kp new file mode 100644 index 0000000..33808e1 --- /dev/null +++ b/koka_bench/kraken/rbtree.kp @@ -0,0 +1,309 @@ +((wrap (vau root_env (quote) +((wrap (vau (let1) +(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se))) +(let1 current-env (vau de () de) +(let1 cons (lambda (h t) (concat (array h) t)) +(let1 Y (lambda (f3) + ((lambda (x1) (x1 x1)) + (lambda (x2) (f3 (wrap (vau app_env (& y) (lapply (x2 x2) y app_env))))))) +(let1 vY (lambda (f) + ((lambda (x3) (x3 x3)) + (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1)))))) +(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2) + true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2))))) + (let ( + lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args))))) + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + if (vau de (con than & else) (eval (array cond con than + true (cond (> (len else) 0) (idx else 0) + true false)) de)) + + map (lambda (f5 l5) + (let (helper (rec-lambda recurse (f4 l4 n4 i4) + (cond (= i4 (len l4)) n4 + (<= i4 (- (len l4) 4)) (recurse f4 l4 (concat n4 (array + (f4 (idx l4 (+ i4 0))) + (f4 (idx l4 (+ i4 1))) + (f4 (idx l4 (+ i4 2))) + (f4 (idx l4 (+ i4 3))) + )) (+ i4 4)) + true (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1))))) + (helper f5 l5 (array) 0))) + + + map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (cond (= i (len l)) n + (<= i (- (len l) 4)) (recurse f l (concat n (array + (f (+ i 0) (idx l (+ i 0))) + (f (+ i 1) (idx l (+ i 1))) + (f (+ i 2) (idx l (+ i 2))) + (f (+ i 3) (idx l (+ i 3))) + )) (+ i 4)) + true (recurse f l (concat n (array (f i (idx l i)))) (+ i 1))))) + (helper f l (array) 0))) + + filter_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (if (f i (idx l i)) (recurse f l (concat n (array (idx l i))) (+ i 1)) + (recurse f l n (+ i 1)))))) + (helper f l (array) 0))) + filter (lambda (f l) (filter_i (lambda (i x) (f x)) l)) + + ; Huge thanks to Oleg Kiselyov for his fantastic website + ; http://okmij.org/ftp/Computation/fixed-point-combinators.html + Y* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (lambda (& x) (lapply (lapply li (p p)) x))) l)))) + vY* (lambda (& l) + ((lambda (u) (u u)) + (lambda (p) + (map (lambda (li) (vau ide (& x) (vapply (lapply li (p p)) x ide))) l)))) + + let-rec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array Y*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + let-vrec (vau de (name_func body) + (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func) + funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func) + overwrite_name (idx name_func (- (len name_func) 2))) + (eval (array let (concat (array overwrite_name (concat (array vY*) (map (lambda (f) (array lambda names f)) funcs))) + (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names))) + body) de))) + + flat_map (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + flat_map_i (lambda (f l) + (let (helper (rec-lambda recurse (f l n i) + (if (= i (len l)) + n + (recurse f l (concat n (f i (idx l i))) (+ i 1))))) + (helper f l (array) 0))) + + ; with all this, we make a destrucutring-capable let + let (let ( + destructure_helper (rec-lambda recurse (vs i r) + (cond (= (len vs) i) r + (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i))) + new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i)) + ) + (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1)))))) + true (recurse vs (+ i 2) (concat r (slice vs i (+ i 2)))) + ))) (vau de (vs b) (vapply let (array (destructure_helper vs 0 (array)) b) de))) + + ; and a destructuring-capable lambda! + only_symbols (rec-lambda recurse (a i) (cond (= i (len a)) true + (symbol? (idx a i)) (recurse a (+ i 1)) + true false)) + + ; Note that if macro_helper is inlined, the mapping lambdas will close over + ; se, and then not be able to be taken in as values to the maps, and the vau + ; will fail to partially evaluate away. + lambda (let (macro_helper (lambda (p b) (let ( + sym_params (map (lambda (param) (if (symbol? param) param + (str-to-symbol (str param)))) p) + body (array let (flat_map_i (lambda (i x) (array (idx p i) x)) sym_params) b) + ) (array vau sym_params body)))) + (vau se (p b) (if (only_symbols p 0) (vapply lambda (array p b) se) + (wrap (eval (macro_helper p b) se))))) + + ; and rec-lambda - yes it's the same definition again + rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se)) + + nil (array) + not (lambda (x) (if x false true)) + or (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) false + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp 'tmp (recurse bs (+ i 1))))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i (len bs)) true + (= (+ 1 i) (len bs)) (idx bs i) + true (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp))))) + (vau se (& bs) (eval (macro_helper bs 0) se))) + + + + foldl (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (recurse f (lapply f (cons z (map (lambda (x) (idx x i)) vs))) vs (+ i 1))))) + (lambda (f z & vs) (helper f z vs 0))) + foldr (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z + (lapply f (cons (recurse f z vs (+ i 1)) (map (lambda (x) (idx x i)) vs)))))) + (lambda (f z & vs) (helper f z vs 0))) + reverse (lambda (x) (foldl (lambda (acc i) (cons i acc)) (array) x)) + zip (lambda (& xs) (lapply foldr (concat (array (lambda (a & ys) (cons ys a)) (array)) xs))) + + match (let ( + evaluate_case (rec-lambda evaluate_case (access c) (cond + (symbol? c) (array true (lambda (b) (array let (array c access) b))) + (and (array? c) (= 2 (len c)) (= 'unquote (idx c 0))) (array (array = access (idx c 1)) (lambda (b) b)) + (and (array? c) (= 2 (len c)) (= 'quote (idx c 0))) (array (array = access c) (lambda (b) b)) + (array? c) (let ( + tests (array and (array array? access) (array = (len c) (array len access))) + (tests body_func) ((rec-lambda recurse (tests body_func i) (if (= i (len c)) + (array tests body_func) + (let ( (inner_test inner_body_func) (evaluate_case (array idx access i) (idx c i)) ) + (recurse (concat tests (array inner_test)) + (lambda (b) (body_func (inner_body_func b))) + (+ i 1))))) + tests (lambda (b) b) 0) + ) (array tests body_func)) + true (array (array = access c) (lambda (b) b)) + )) + helper (rec-lambda helper (x_sym cases i) (cond (< i (- (len cases) 1)) (let ( (test body_func) (evaluate_case x_sym (idx cases i)) ) + (concat (array test (body_func (idx cases (+ i 1)))) (helper x_sym cases (+ i 2)))) + true (array true (array error "none matched")))) + ) (vau de (x & cases) (eval (array let (array '___MATCH_SYM x) (concat (array cond) (helper '___MATCH_SYM cases 0))) de))) + + ; This is based on https://www.cs.cornell.edu/courses/cs3110/2020sp/a4/deletion.pdf + ; and the figure references refer to it + ; Insert is taken from the same paper, but is origional to Okasaki, I belive + + ; The tree has been modified slightly to take in a comparison function + ; and override if insert replaces or not to allow use as a set or as a map + + ; I think this is actually pretty cool - instead of having a bunch of seperate ['B] + ; be our leaf node, we use ['B] with all nils. This allows us to not use -B, as + ; both leaf and non-leaf 'BB has the same structure with children! Also, we make + ; sure to use empty itself so we don't make a ton of empties... + empty (array 'B nil nil nil) + E empty + EE (array 'BB nil nil nil) + + size (rec-lambda recurse (t) (match t + ,E 0 + (c a x b) (+ 1 (recurse a) (recurse b)))) + + generic-foldl (rec-lambda recurse (f z t) (match t + ,E z + (c a x b) (recurse f (f (recurse f z a) x) b))) + + generic-contains? (rec-lambda recurse (t cmp v found not-found) (match t + ,E (not-found) + (c a x b) (match (cmp v x) '< (recurse a cmp v found not-found) + '= (found x) + '> (recurse b cmp v found not-found)))) + blacken (lambda (t) (match t + ('R a x b) (array 'B a x b) + t t)) + balance (lambda (t) (match t + ; figures 1 and 2 + ('B ('R ('R a x b) y c) z d) (array 'R (array 'B a x b) y (array 'B c z d)) + ('B ('R a x ('R b y c)) z d) (array 'R (array 'B a x b) y (array 'B c z d)) + ('B a x ('R ('R b y c) z d)) (array 'R (array 'B a x b) y (array 'B c z d)) + ('B a x ('R b y ('R c z d))) (array 'R (array 'B a x b) y (array 'B c z d)) + ; figure 8, double black cases + ('BB ('R a x ('R b y c)) z d) (array 'B (array 'B a x b) y (array 'B c z d)) + ('BB a x ('R ('R b y c) z d)) (array 'B (array 'B a x b) y (array 'B c z d)) + ; already balenced + t t)) + generic-insert (lambda (t cmp v replace) (let ( + ins (rec-lambda ins (t) (match t + ,E (array 'R t v t) + (c a x b) (match (cmp v x) '< (balance (array c (ins a) x b)) + '= (if replace (array c a v b) + t) + '> (balance (array c a x (ins b)))))) + ) (blacken (ins t)))) + + rotate (lambda (t) (match t + ; case 1, fig 6 + ('R ('BB a x b) y ('B c z d)) (balance (array 'B (array 'R (array 'B a x b) y c) z d)) + ('R ('B a x b) y ('BB c z d)) (balance (array 'B a x (array 'R b y (array 'B c z d)))) + ; case 2, figure 7 + ('B ('BB a x b) y ('B c z d)) (balance (array 'BB (array 'R (array 'B a x b) y c) z d)) + ('B ('B a x b) y ('BB c z d)) (balance (array 'BB a x (array 'R b y (array 'B c z d)))) + ; case 3, figure 9 + ('B ('BB a w b) x ('R ('B c y d) z e)) (array 'B (balance (array 'B (array 'R (array 'B a w b) x c) y d)) z e) + ('B ('R a w ('B b x c)) y ('BB d z e)) (array 'B a w (balance (array 'B b x (array 'R c y (array 'B d z e))))) + ; fall through + t t)) + + redden (lambda (t) (match t + ('B a x b) (if (and (= 'B (idx a 0)) (= 'B (idx b 0))) (array 'R a x b) + t) + t t)) + + min_delete (rec-lambda recurse (t) (match t + ,E (error "min_delete empty tree") + ('R ,E x ,E) (array x E) + ('B ,E x ,E) (array x EE) + ('B ,E x ('R a y b)) (array x (array 'B a y b)) + (c a x b) (let ((v ap) (recurse a)) (array v (rotate (array c ap x b)))))) + + generic-delete (lambda (t cmp v) (let ( + del (rec-lambda del (t v) (match t + ; figure 3 + ,E t + ; figure 4 + ('R ,E x ,E) (match (cmp v x) '= E + _ t) + ('B ('R a x b) y ,E) (match (cmp v y) '< (rotate (array 'B (del (array 'R a x b) v) y E)) + '= (array 'B a x b) + '> t) + ; figure 5 + ('B ,E x ,E) (match (cmp v x) '= EE + _ t) + (c a x b) (match (cmp v x) '< (rotate (array c (del a v) x b)) + '= (let ((array vp bp) (min_delete b)) + (rotate (array c a vp bp))) + '> (rotate (array c a x (del b v)))))) + ) (del (redden t) v))) + + set-cmp (lambda (a b) (cond (< a b) '< + (= a b) '= + true '>)) + set-empty empty + set-foldl generic-foldl + set-insert (lambda (t x) (generic-insert t set-cmp x false)) + set-contains? (lambda (t x) (generic-contains? t set-cmp x (lambda (f) true) (lambda () false))) + set-remove (lambda (t x) (generic-delete t set-cmp x)) + + map-cmp (lambda (a b) (let (ak (idx a 0) + bk (idx b 0)) + (cond (< ak bk) '< + (= ak bk) '= + true '>))) + map-empty empty + map-insert (lambda (t k v) (generic-insert t map-cmp (array k v) true)) + map-contains-key? (lambda (t k) (generic-contains? t map-cmp (array k nil) (lambda (f) true) (lambda () false))) + map-get (lambda (t k) (generic-contains? t map-cmp (array k nil) (lambda (f) (idx f 1)) (lambda () (error (str "didn't find key " k " in map " t))))) + map-get-or-default (lambda (t k d) (generic-contains? t map-cmp (array k nil) (lambda (f) (idx f 1)) (lambda () d))) + map-get-with-default (lambda (t k d) (generic-contains? t map-cmp (array k nil) (lambda (f) (idx f 1)) (lambda () (d)))) + map-remove (lambda (t k) (generic-delete t map-cmp (array k nil))) + + ; This could be 2x as efficent by being implmented on generic instead of map, + ; as we wouldn't have to traverse once to find and once to insert + multimap-empty map-empty + multimap-insert (lambda (t k v) (map-insert t k (set-insert (map-get-or-default t k set-empty) v))) + multimap-get (lambda (t k) (map-get-or-default t k set-empty)) + + + + make-test-tree (rec-lambda make-test-tree (n t) (cond (<= n 0) t + true (make-test-tree (- n 1) (map-insert t n (= 0 (% n 10)))))) + reduce-test-tree (lambda (tree) (generic-foldl (lambda (a x) (if (idx x 1) (+ a 1) a)) 0 tree)) + + monad (array 'write 1 (str "running tree test") (vau (written code) + (array 'args (vau (args code) + (array 'exit (log (reduce-test-tree (make-test-tree (read-string (idx args 1)) map-empty)))) + )) + )) + + ) monad) +; end of all lets +)))))) +; impl of let1 +)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de))) +; impl of quote +)) (vau (x5) x5)) diff --git a/working_files/fib.c b/working_files/fib.c new file mode 100644 index 0000000..54fea15 --- /dev/null +++ b/working_files/fib.c @@ -0,0 +1,17 @@ +#include + +int fib(int n) { + if (n == 0) { + return 0; + } else if (n == 1) { + return 1; + } else { + return fib(n-1) + fib(n-2); + } +} + +int main(int argc, char** argv) { + int n = 27; + printf("Fib(%d): %d\n", n, fib(n)); + return 0; +}