diff --git a/partial_eval.csc b/partial_eval.csc index 82992de..ae4de9d 100644 --- a/partial_eval.csc +++ b/partial_eval.csc @@ -118,7 +118,7 @@ (nil? (lambda (x) (= nil x))) (bool? (lambda (x) (or (= #t x) (= #f x)))) (true_print print) - ;(print (lambda x 0)) + (print (lambda x 0)) ;(true_print print) (println print) @@ -196,6 +196,7 @@ (.marked_symbol_value (lambda (x) (idx x 3))) (.comb (lambda (x) (slice x 2 -1))) (.comb_id (lambda (x) (idx x 3))) + (.comb_des (lambda (x) (idx x 4))) (.comb_env (lambda (x) (idx x 5))) (.comb_body (lambda (x) (idx x 8))) (.comb_wrap_level (lambda (x) (idx x 2))) @@ -243,7 +244,9 @@ (hash_string (lambda (s) (foldl combine_hash 7 (map char->integer (string->list s))))) (hash_symbol (lambda (progress_idxs s) (combine_hash (if (= true progress_idxs) 11 (foldl combine_hash 13 (map (lambda (x) (if (= true x) 13 (+ 1 x))) progress_idxs))) (hash_string (symbol->string s))))) - (hash_array (lambda (is_val attempted a) (foldl combine_hash (if is_val 17 (if attempted 19 61)) (map .hash a)))) + (hash_array (lambda (is_val attempted a) (foldl combine_hash (if is_val 17 (cond ((int? attempted) (combine_hash attempted 19)) + (attempted 61) + (true 107))) (map .hash a)))) (hash_env (lambda (progress_idxs dbi arrs) (combine_hash (mif dbi (hash_num dbi) 59) (let* ( (inner_hash (foldl (dlambda (c (s v)) (combine_hash c (combine_hash (hash_symbol true s) (.hash v)))) (cond ((= nil progress_idxs) 23) @@ -284,9 +287,10 @@ ) (array true (array) resume_hashes) (map needed_for_progress x))) ;(_ (print "got " sub_progress_idxs " out of " x)) ;(_ (print "\twhich evalated to " (map needed_for_progress x))) - (progress_idxs (cond ((and (= nil sub_progress_idxs) (not is_val) attempted) nil) - ((and (= nil sub_progress_idxs) (not is_val) (not attempted)) true) - (true sub_progress_idxs))) + (progress_idxs (cond ((and (= nil sub_progress_idxs) (not is_val) (= true attempted)) nil) + ((and (= nil sub_progress_idxs) (not is_val) (= false attempted)) true) + ((and (= nil sub_progress_idxs) (not is_val) (int? attempted)) (array attempted)) + (true sub_progress_idxs))) ) (array 'marked_array (hash_array is_val attempted x) is_val attempted (array progress_idxs hashes) x)))) (marked_env (lambda (has_vals progress_idxs dbi arrs) (array 'env (hash_env progress_idxs dbi arrs) has_vals progress_idxs dbi arrs))) (marked_val (lambda (x) (array 'val (hash_val x) x))) @@ -347,7 +351,7 @@ ((marked_array? x) (dlet (((stripped_values done_envs) (foldl (dlambda ((vs de) x) (dlet (((v de) (recurse x de))) (array (concat vs (array v)) de))) (array (array) done_envs) (.marked_array_values x)))) (mif (.marked_array_is_val x) (array (str "[" stripped_values "]") done_envs) - (array (str "" stripped_values) done_envs)))) + (array (str "" stripped_values) done_envs)))) ((marked_symbol? x) (mif (.marked_symbol_is_val x) (array (str "'" (.marked_symbol_value x)) done_envs) (array (str (.marked_symbol_needed_for_progress x) "#" (.marked_symbol_value x)) done_envs))) ((comb? x) (dlet (((wrap_level env_id de? se variadic params body) (.comb x)) @@ -373,7 +377,7 @@ ) ) (idx args -1) (array)) 0)))))) (true_str_strip str_strip) - ;(str_strip (lambda args 0)) + (str_strip (lambda args 0)) ;(true_str_strip str_strip) (print_strip (lambda args (println (apply str_strip args)))) @@ -397,7 +401,11 @@ ((marked_env? x) (error "got env for strip, won't work")) (true (error (str "some other strip? " x))) ) - ))) (lambda (x) (let* ((_ (print_strip "stripping: " x)) (r (helper x true)) (_ (println "result of strip " r))) r)))) + ))) (lambda (x) (let* ( + ;(_ (print_strip "stripping: " x)) + (r (helper x true)) + ;(_ (println "result of strip " r)) + ) r)))) (try_unval (rec-lambda recurse (x fail_f) (cond ((marked_array? x) (mif (not (.marked_array_is_val x)) (array false (fail_f x)) @@ -460,7 +468,7 @@ )))) (array) s_env_id x) 1))) (comb_takes_de? (lambda (x l) (cond - ((comb? x) (dlet (((wrap_level env_id de? se variadic params body) (.comb x))) (!= nil de?))) + ((comb? x) (!= nil (.comb_des x))) ((prim_comb? x) (cond ( (= (.prim_comb_sym x) 'vau) true) ((and (= (.prim_comb_sym x) 'eval) (= 1 l)) true) ((and (= (.prim_comb_sym x) 'veval) (= 1 l)) true) @@ -601,6 +609,7 @@ (env-lookup-helper (.env_marked env) (.marked_symbol_value x) 0 (lambda () (array pectx (str "could't find " (str_strip x) " in " (str_strip env)) nil)) (lambda (x) (array pectx nil x))))) + ; Does this ever happen? non-fully-value arrays? ((marked_array? x) (cond ((.marked_array_is_val x) (dlet ( ((pectx err inner_arr) (foldl (dlambda ((c er ds) p) (dlet (((c e d) (partial_eval_helper p false env env_stack c (+ 1 indent) false))) (array c (mif er er e) (concat ds (array d))))) (array pectx nil (array)) (.marked_array_values x))) @@ -694,9 +703,12 @@ ) (array pectx func_err func_result false)))) (_ (print_strip (indent_str indent) "evaled result of function call (in env " (.marked_env_idx env) ", with inner " env_id ") and err " func_err " is " func_result)) + (must_stop_maybe_id (or rec_stop (if (not (combiner_return_ok func_result env_id)) + (if (!= nil de?) (.marked_env_idx env) true) + false))) ) (if (!= nil func_err) (array pectx func_err nil) - (if (or rec_stop (not (combiner_return_ok func_result env_id))) - (array pectx nil (marked_array false true (if rec_stop (array hash) nil) (cons (with_wrap_level comb remaining_wrap) evaled_params))) + (if must_stop_maybe_id + (array pectx nil (marked_array false must_stop_maybe_id (if rec_stop (array hash) nil) (cons (with_wrap_level comb remaining_wrap) evaled_params))) (drop_redundent_veval partial_eval_helper func_result env env_stack pectx indent))))) ))) ))))) @@ -3881,6 +3893,8 @@ (print (slice '(1 2 3) -2 -1)) (print "ASWDF") + (print (str-to-symbol (str '(a b)))) + (print (symbol? (str-to-symbol (str '(a b))))) (print ( (dlambda ((a b)) a) '(1337 1338))) (print ( (dlambda ((a b)) b) '(1337 1338))) diff --git a/to_compile.kp b/to_compile.kp index 103c410..1613e9d 100644 --- a/to_compile.kp +++ b/to_compile.kp @@ -12,12 +12,11 @@ (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 ( - ;a 1 - ;lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args))))) + 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) (cond (eval con de) (eval than de) - ; (> (len else) 0) (eval (idx else 0) de) - ; true false)) + if (vau de (con than & else) (cond (eval con de) (eval than de) + (> (len else) 0) (eval (idx else 0) de) + true false)) map (lambda (f5 l5) ; now maybe errors on can't find helper? @@ -31,16 +30,124 @@ )) (+ i4 4)) true (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1))))) (helper f5 l5 (array) 0))) - test (map (lambda (x) (+ x 1)) (array 1 2)) - ;test ((rec-lambda recurse (n) (cond (= 0 n) 1 - ; true (* n (recurse (- n 1))))) 5) + + + 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)) + + not (lambda (x) (if x false true)) + + ; 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))) (slice (idx vs i) 1 -1)) + 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)) + lambda (vau se (p b) (if (only_symbols p 0) (vapply lambda (array p b) se) + (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) + ) (wrap (eval (array vau sym_params body) 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)) + + + test0 (map (lambda (x) (+ x 1)) (array 1 2)) + test1 (map_i (lambda (i x) (+ x i 1)) (array 1 2)) + test2 (filter_i (lambda (i x) (> i 0)) (array 1 2)) + test2 (filter (lambda ( x) (> x 1)) (array 1 2)) + test3 (not 1) + test4 (flat_map (lambda (x) (array 1 x 2)) (array 1 2)) + test5 (flat_map_i (lambda (i x) (array i x 2)) (array 1 2)) + test6 (let ( (a b) (array 1 2) c (+ a b) ) c) + test7 ((rec-lambda recurse (n) (cond (= 0 n) 1 + true (* n (recurse (- n 1))))) 5) + test8 ((lambda (a b c) (+ a b c)) 1 13 14) + test9 ((lambda (a (b c)) (+ a b c)) 1 (array 13 14)) ;monad (array 'open 3 "test_self_out" (lambda (fd code) ; (array 'write fd "wabcdefghijklmnopqrstuvwx" (lambda (written code) ; (array 'exit (if (= 0 written) 12 14)))))) ;old 4 ;test (+ old 4) ;test 4 - monad (array 'write 1 "test_self_out2" (vau (written code) (map (lambda (x) (+ x 133)) (array written code)))) + ;monad (array 'write 1 "test_self_out2" (vau (written code) (map (lambda (x) (+ x 133)) (array written code)))) + ;monad (array 'write 1 "test_self_out2" (vau (written code) (map_i (lambda (i x) (+ x i 133)) (array written code)))) + ;monad (array 'write 1 "test_self_out2" (vau (written code) (filter_i (lambda (i x) (> i 0)) (array written code)))) + ;monad (array 'write 1 "test_self_out2" (vau (written code) (filter (lambda (x) (> x 0)) (array written code)))) + ;monad (array 'write 1 "test_self_out2" (vau (written code) (not (array written code)))) + ;monad (array 'write 1 "test_self_out2" (vau (written code) (flat_map (lambda (x) (array 1 x 2)) (array written code)))) + ;monad (array 'write 1 "test_self_out2" (vau (written code) (flat_map_i (lambda (i x) (array i x 2)) (array written code)))) + monad (array 'write 1 "test_self_out2" (vau (written code) (let ( (a b) (array written code) c (+ a b test8 test9)) c))) + ;monad (array 'write 1 "test_self_out2" (vau (written code) ((lambda (a (b c)) (+ a b c)) 1 (array written code)))) ) monad )