((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 (lambda (& y) (lapply (x2 x2) y)))))) (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) (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? (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)) 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)) ; 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)) 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))) id (lambda (x) x) dlet (vau se (inners body) (vapply let (array (lapply concat inners) body) se)) test7 ((rec-lambda recurse (n) (cond (= 0 n) 1 true (* n (recurse (- n 1))))) 5) nil (array) cond (vau se (& inners) (vapply cond (lapply concat inners) se)) test18 ((rec-lambda recurse (n) (cond ((= 0 n) 1) (true (* n (recurse (- n 1)))))) 5) ;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) ;test8 ((lambda (a b c) (+ a b c)) 1 13 14) ;test9 ((lambda (a (b c)) (+ a b c)) 1 (array 13 14)) ;test10 (foldl + 0 (array 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 13371 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337)) ;test11 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 13371 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337)) ;test12 (foldl + 0 (array 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 13371 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337)) ;test13 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 13371 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337)) ;test10 (foldl + 0 (array 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337)) ;test11 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337)) ;test10 (foldl + 0 (array 1 2 3 4 1337 6 4 4 4 1337 1 2 3 4 1337 6 4 4 4 1337)) ;test11 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337)) ;test12 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337)) ;test13 (foldl + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337)) ;test14 (foldr + 0 (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337)) ;test15 (reverse (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337)) ;test16 (zip (array 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337 1 2 3 4 1337) (array 2 3 4 5 1338 2 3 4 5 1338 2 3 4 5 1338 2 3 4 5 1338)) ;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_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 (array 'write 1 "test_self_out2" (vau (written code) test10)) ;monad (array 'write 1 "test_self_out2" (vau (written code) (foldl + 0 (array written code 1337)))) ;monad (array 'write 1 "test_self_out2" (vau (written code) test14)) ;monad (array 'write 1 "test_self_out2" (vau (written code) (foldr + 0 (array written code 1337)))) ;monad (array 'write 1 "test_self_out2" (vau (written code) test15)) ;monad (array 'write 1 "test_self_out2" (vau (written code) (reverse (array written code 1337)))) ;monad (array 'write 1 "test_self_out2" (vau (written code) test16)) monad (array 'write 1 "test_self_out2" (vau (written code) (zip (array 1 2 3) (array written code 1337)))) test17 (dlet ( (a 1) (b 2) ((c d) (array 3 4)) ) (+ a b c d)) ;monad (array 'write 1 "test_self_out2" (vau (written code) test17)) ;monad (array 'write 1 "test_self_out2" (vau (written code) (+ test7 test18))) ;monad (array 'write 1 "test_self_out2" (vau (written code) 7)) print log println log ) ; monad (dlet ( (in_array (dlet ((helper (rec-lambda recurse (x a i) (cond ((= i (len a)) false) ((= x (idx a i)) true) (true (recurse x a (+ i 1))))))) (lambda (x a) (helper x a 0)))) (val? (lambda (x) (= 'val (idx x 0)))) (marked_array? (lambda (x) (= 'marked_array (idx x 0)))) (marked_symbol? (lambda (x) (= 'marked_symbol (idx x 0)))) (comb? (lambda (x) (= 'comb (idx x 0)))) (prim_comb? (lambda (x) (= 'prim_comb (idx x 0)))) (marked_env? (lambda (x) (= 'env (idx x 0)))) (.hash (lambda (x) (idx x 1))) (.val (lambda (x) (idx x 2))) (.marked_array_is_val (lambda (x) (idx x 2))) (.marked_array_is_attempted (lambda (x) (idx x 3))) (.marked_array_needed_for_progress (lambda (x) (idx x 4))) (.marked_array_values (lambda (x) (idx x 5))) (.marked_symbol_needed_for_progress (lambda (x) (idx x 2))) (.marked_symbol_is_val (lambda (x) (= nil (.marked_symbol_needed_for_progress x)))) (.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))) (.prim_comb_sym (lambda (x) (idx x 3))) (.prim_comb_handler (lambda (x) (idx x 2))) (.prim_comb_wrap_level (lambda (x) (idx x 4))) (.prim_comb_val_head_ok (lambda (x) (idx x 5))) (.prim_comb (lambda (x) (slice x 2 -1))) (.marked_env (lambda (x) (slice x 2 -1))) (.marked_env_has_vals (lambda (x) (idx x 2))) (.marked_env_needed_for_progress (lambda (x) (idx x 3))) (.marked_env_idx (lambda (x) (idx x 4))) (.marked_env_upper (lambda (x) (idx (idx x 5) -1))) (.env_marked (lambda (x) (idx x 5))) (marked_env_real? (lambda (x) (= nil (.marked_env_needed_for_progress x)))) (.any_comb_wrap_level (lambda (x) (cond ((prim_comb? x) (.prim_comb_wrap_level x)) ((comb? x) (.comb_wrap_level x)) (true (error "bad .any_comb_level"))))) ; The actual needed_for_progress values are either ; #t - any eval will do something ; nil - is a value, no eval will do anything ; (3 4 1...) - list of env ids that would allow forward progress ; But these are paired with another list of hashes that if you're not inside ; of an evaluation of, then it could progress futher. These are all caused by ; the infinite recursion stopper. (needed_for_progress (rec-lambda needed_for_progress (x) (cond ((marked_array? x) (.marked_array_needed_for_progress x)) ((marked_symbol? x) (array (.marked_symbol_needed_for_progress x) nil)) ((marked_env? x) (array (.marked_env_needed_for_progress x) nil)) ;((comb? x) (dlet ((id (.comb_id x)) ; (body_needed (idx (needed_for_progress (.comb_body x)) 0)) ; (se_needed (idx (needed_for_progress (.comb_env x)) 0))) ; (if (or (= true body_needed) (= true se_needed)) (array true nil) ; (array (foldl (lambda (a xi) (if (or (= id xi) (in_array xi a)) a (cons xi a))) ; (array) (concat body_needed se_needed)) nil) ; ))) ((prim_comb? x) (array nil nil)) ((val? x) (array nil nil)) (true (error (str "what is this? in need for progress" x)))))) (needed_for_progress_slim (lambda (x) (idx (needed_for_progress x) 0))) (monad (array 'write 1 "test_self_out2" (vau (written code) (dlet ((_ (print 1234))) (in_array 0 (array written code)))))) ) monad) ) ;(array 'write 1 "test_self_out2" (vau (written code) 7)) ; end of all lets )))))) ; impl of let1 ; this would be the macro style version ((( )) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de))) ;)) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de))) ; impl of quote )) (vau (x5) x5))