2021-11-09 00:35:58 -05:00
(import (chicken process-context))
(import (chicken port))
(import (r5rs))
(define-syntax rec-lambda
(er-macro-transformer
(lambda (x r c)
(let (
(name (car (cdr x)))
(params (car (cdr (cdr x))))
(body (car (cdr (cdr (cdr x)))))
)
`(rec ,name (lambda ,params ,body))))))
2021-11-16 00:15:53 -05:00
(define-syntax dlet
(er-macro-transformer
(lambda (x r c)
(let* (
2021-11-20 01:13:22 -05:00
(items (list-ref x 1))
(body (list-ref x 2))
(flat_map_i (lambda (f l) ((rec recurse (lambda (f l i) (cond
((equal? '() l) '())
(#t (append (f i (car l)) (recurse f (cdr l) (+ i 1)))))
)) f l 0)))
(flatten-helper (rec recurse (lambda (items)
(cond
((equal? '() items) '())
(#t (let* (
(clause (car items))
(result (cond
((list? (car clause)) (let ((s (gensym)))
(cons `(,s ,(car (cdr clause)))
(flat_map_i (lambda (i x)
(recurse `((,x (list-ref ,s ,i))))
)
(car clause)))))
(#t (list clause))))
) (append result (recurse (cdr items)))))
))))
2021-11-19 01:08:27 -05:00
2021-11-16 00:15:53 -05:00
(flat_items (flatten-helper items))
(_ (print items " flattened " flat_items))
) `(let* ,flat_items ,body)
))))
2021-11-19 01:08:27 -05:00
(define-syntax dlambda
(er-macro-transformer
(lambda (x r c)
(let (
(params (list-ref x 1))
(param_sym (gensym))
(body (list-ref x 2))
)
`(lambda ,param_sym (dlet ( (,params ,param_sym) ) ,body))))))
2021-11-16 00:15:53 -05:00
2021-11-22 01:28:05 -05:00
(define-syntax needs_params_val_lambda
(er-macro-transformer
(lambda (x r c)
(let ((f_sym (list-ref x 1)))
`(needs_params_val_lambda_inner ',f_sym ,f_sym)))))
2021-11-23 01:54:20 -05:00
(define-syntax give_up_eval_params
(er-macro-transformer
(lambda (x r c)
(let ((f_sym (list-ref x 1)))
`(give_up_eval_params_inner ',f_sym ,f_sym)))))
2021-11-23 22:16:24 -05:00
(define-syntax mif
(er-macro-transformer
(lambda (x r c)
(let (
(cond (list-ref x 1))
(v (gensym))
(then (list-ref x 2))
(else (if (equal? 4 (length x)) (list-ref x 3) ''()))
)
`(let ((,v ,cond)) (if (and (not (equal? (array) ,v)) ,v) ,then ,else))))))
2021-11-23 01:54:20 -05:00
2021-11-09 00:35:58 -05:00
(let* (
2021-11-23 01:54:20 -05:00
(= equal?)
(!= (lambda (a b) (not (= a b))))
2021-11-09 00:35:58 -05:00
(array list)
2021-11-22 01:28:05 -05:00
(array? list?)
2021-11-09 00:35:58 -05:00
(concat append)
(len length)
2021-11-23 22:16:24 -05:00
(idx (lambda (x i) (list-ref x (mif (< i 0) (+ i (len x)) i))))
2021-11-16 00:15:53 -05:00
(false #f)
(true #t)
(nil '())
2021-11-23 01:54:20 -05:00
(str-to-symbol string->symbol)
(get-text symbol->string)
2021-11-09 00:35:58 -05:00
2021-11-23 01:54:20 -05:00
(nil? (lambda (x) (= nil x)))
(bool? (lambda (x) (or (= #t x) (= #f x))))
2021-11-22 01:28:05 -05:00
(println print)
2021-11-23 01:54:20 -05:00
(read-string (lambda (s) (read (open-input-string s))))
2021-11-23 22:16:24 -05:00
(zip (lambda args (apply map list args)))
2021-11-22 01:28:05 -05:00
(% modulo)
(int? integer?)
(env? (lambda (x) false))
(combiner? (lambda (x) false))
2021-11-23 22:16:24 -05:00
(drop (rec-lambda recurse (x i) (mif (= 0 i) x (recurse (cdr x) (- i 1)))))
(take (rec-lambda recurse (x i) (mif (= 0 i) (array) (cons (car x) (recurse (cdr x) (- i 1))))))
2021-11-09 00:35:58 -05:00
(slice (lambda (x s e) (let* ( (l (len x))
2021-11-23 22:16:24 -05:00
(s (mif (< s 0) (+ s l 1) s))
(e (mif (< e 0) (+ e l 1) e))
2021-11-09 00:35:58 -05:00
(t (- e s)) )
(take (drop x s) t))))
2021-11-24 00:45:44 -05:00
(filter (rec-lambda recurse (f l) (cond ((nil? l) nil)
((f (car l)) (cons (car l) (recurse f (cdr l))))
(true (recurse f (cdr l))))))
2021-11-16 00:15:53 -05:00
(str (lambda args (begin
(define mp (open-output-string))
(display args mp)
(get-output-string mp))))
)
2021-11-09 00:35:58 -05:00
(let* (
(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))))
2021-11-25 23:57:23 -05:00
(marked_env_real? (lambda (x) (idx x 2)))
(.val (lambda (x) (idx x 2)))
(.marked_array_is_val (lambda (x) (idx x 2)))
(.marked_array_values (lambda (x) (idx x 3)))
(.marked_symbol_is_val (lambda (x) (idx x 2)))
(.marked_symbol_value (lambda (x) (idx x 3)))
(.comb (lambda (x) (slice x 2 -1)))
(.prim_comb (lambda (x) (idx x 2)))
(.marked_env (lambda (x) (slice x 2 -1)))
(.marked_env_idx (lambda (x) (idx x 3)))
(.env_marked (lambda (x) (idx x 4)))
(.hash (lambda (x) (idx x 1)))
(combine_hash (lambda (a b) (+ (* 37 a) b)))
(hash_bool (lambda (b) (if b 2 3)))
(hash_num (lambda (n) (combine_hash 5 n)))
(hash_string (lambda (s) (foldl combine_hash 7 (map char->integer (string->list s)))))
(hash_symbol (lambda (is_val s) (combine_hash (if is_val 11 13) (hash_string (symbol->string s)))))
(hash_array (lambda (is_val a) (foldl combine_hash (if is_val 17 19) (map .hash a))))
(hash_env (lambda (is_real 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 false s) (.hash v))))
(if is_real 23 29)
(slice arrs 0 -2)))
(end (idx arrs -1))
(end_hash (mif end (.hash end) 31))
) (combine_hash inner_hash end_hash)))))
(hash_comb (lambda (wrap_level de? se variadic params body) (combine_hash 41
(combine_hash (mif de? (hash_symbol false de?) 43)
(combine_hash (.hash se)
(combine_hash (hash_bool variadic)
(combine_hash (foldl (lambda (c x) (combine_hash c (hash_symbol false x))) 47 params)
(.hash body))))))))
(hash_prim_comb (lambda (handler_fun real_or_name) (combine_hash 53 (hash_symbol false real_or_name))))
(hash_val (lambda (x) (cond ((bool? x) (hash_bool x))
((string? x) (hash_string x))
((int? x) (hash_num x))
(true (error (str "bad thing to hash_val " x))))))
; 41 43 47 53 59 61 67 71
(marked_symbol (lambda (is_val x) (array 'marked_symbol (hash_symbol is_val x) is_val x)))
(marked_array (lambda (is_val x) (array 'marked_array (hash_array is_val x) is_val x)))
(marked_val (lambda (x) (array 'val (hash_val x) x)))
(marked_env (lambda (is_real dbi arrs) (array 'env (hash_env is_real dbi arrs) is_real dbi arrs)))
(marked_comb (lambda (wrap_level de? se variadic params body) (array 'comb (hash_comb wrap_level de? se variadic params body) wrap_level de? se variadic params body)))
(marked_prim_comb (lambda (handler_fun real_or_name) (array 'prim_comb (hash_prim_comb handler_fun real_or_name) handler_fun real_or_name)))
2021-11-16 00:15:53 -05:00
(later? (rec-lambda recurse (x) (or (and (marked_array? x) (or (= false (.marked_array_is_val x)) (foldl (lambda (a x) (or a (recurse x))) false (.marked_array_values x))))
(and (marked_symbol? x) (= false (.marked_symbol_is_val x)))
)))
(false? (lambda (x) (cond ((and (marked_array? x) (= false (.marked_array_is_val x))) (error "got a later marked_array passed to false? " x))
((and (marked_symbol? x) (= false (.marked_symbol_is_val x))) (error "got a later marked_symbol passed to false? " x))
((val? x) (not (.val x)))
(true false))))
(env-lookup-helper (rec-lambda recurse (dict key i fail success) (cond ((and (= i (- (len dict) 1)) (= nil (idx dict i))) (fail))
((= i (- (len dict) 1)) (recurse (.env_marked (idx dict i)) key 0 fail success))
((= key (idx (idx dict i) 0)) (success (idx (idx dict i) 1)))
(true (recurse dict key (+ i 1) fail success)))))
(env-lookup (lambda (env key) (env-lookup-helper (.env_marked env) key 0 (lambda () (error key " not found in env " (.env_marked env))) (lambda (x) x))))
(mark (rec-lambda recurse (x) (cond ((env? x) (error "called mark with an env " x))
((combiner? x) (error "called mark with a combiner " x))
2021-11-25 23:57:23 -05:00
((symbol? x) (cond ((= 'true x) (marked_val #t))
((= 'false x) (marked_val #f))
(#t (marked_symbol false x))))
((array? x) (marked_array false (map recurse x)))
(true (marked_val x)))))
2021-11-16 00:15:53 -05:00
2021-11-23 22:16:24 -05:00
(indent_str (rec-lambda recurse (i) (mif (= i 0) ""
2021-11-16 00:15:53 -05:00
(str " " (recurse (- i 1))))))
2021-11-19 01:08:27 -05:00
(str_strip (lambda args (apply str (concat (slice args 0 -2) (array ((rec-lambda recurse (x)
(cond ((val? x) (.val x))
((marked_array? x) (let ((stripped_values (map recurse (.marked_array_values x))))
2021-11-23 22:16:24 -05:00
(mif (.marked_array_is_val x) (cons array stripped_values)
2021-11-19 01:08:27 -05:00
stripped_values)))
2021-11-23 22:16:24 -05:00
((marked_symbol? x) (mif (.marked_symbol_is_val x) (array 'quote (.marked_symbol_value x))
2021-11-19 01:08:27 -05:00
(.marked_symbol_value x)))
((comb? x) (dlet (((wrap_level de? se variadic params body) (.comb x)))
(str "<comb " wrap_level " " de? " <se " (recurse se) "> " params " " (recurse body) ">")))
((prim_comb? x) (idx x 2))
2021-11-23 22:16:24 -05:00
((marked_env? x) (let* ((e (.env_marked x))
(index (.marked_env_idx x))
(u (idx e -1))
) (mif u (str "<" (mif (marked_env_real? x) "real" "fake") " ENV idx: " (str index) ", " (map (dlambda ((k v)) (array k (recurse v))) (slice e 0 -2)) " upper: " (recurse u) ">")
2021-11-19 01:08:27 -05:00
"<no_upper_likely_root_env>")))
(true (error (str "some other str_strip? |" x "|")))
)
) (idx args -1)))))))
(print_strip (lambda args (println (apply str_strip args))))
(strip (let ((helper (rec-lambda recurse (x need_value)
(cond ((val? x) (.val x))
((marked_array? x) (let ((stripped_values (map (lambda (x) (recurse x need_value)) (.marked_array_values x))))
2021-11-23 22:16:24 -05:00
(mif (.marked_array_is_val x) (mif need_value (error (str "needed value for this strip but got" x)) (cons array stripped_values))
2021-11-19 01:08:27 -05:00
stripped_values)))
2021-11-23 22:16:24 -05:00
((marked_symbol? x) (mif (.marked_symbol_is_val x) (mif need_value (error (str "needed value for this strip but got" x)) (array quote (.marked_symbol_value x)))
2021-11-19 01:08:27 -05:00
(.marked_symbol_value x)))
((comb? x) (dlet (((wrap_level de? se variadic params body) (.comb x))
2021-11-23 22:16:24 -05:00
(de_entry (mif de? (array de?) (array)))
(final_params (mif variadic (concat (slice params 0 -2) '& (array (idx params -1))) params))
2021-11-19 01:08:27 -05:00
; Honestly, could trim down the env to match what could be evaluated in the comb
2021-11-23 22:16:24 -05:00
; Also mif this isn't real, lower to a call to vau
(se_env (mif (marked_env_real? se) (recurse se true) nil))
2021-11-19 01:08:27 -05:00
(body_v (recurse body false))
(ve (concat (array vau) de_entry (array final_params) (array body_v)))
2021-11-23 22:16:24 -05:00
(fe ((rec-lambda recurse (x i) (mif (= i 0) x (recurse (array wrap x) (- i 1)))) ve wrap_level))
) (mif se_env (eval fe se_env) fe)))
2021-11-19 01:08:27 -05:00
((prim_comb? x) (idx x 2))
2021-11-23 22:16:24 -05:00
; env emitting doesn't pay attention to real value right now, not sure mif that makes sense
2021-11-19 01:08:27 -05:00
; TODO: properly handle de Bruijn indexed envs
((marked_env? x) (cond ((and (not need_value) (= 0 (.marked_env_idx x))) (array current-env))
2021-11-23 22:16:24 -05:00
(true (let ((_ (mif (not (marked_env_real? x)) (error (str_strip "trying to emit fake env!" x)))))
2021-11-19 01:08:27 -05:00
(upper (idx (.env_marked x) -1))
2021-11-23 22:16:24 -05:00
(upper_env (mif upper (recurse upper true) empty_env))
2021-11-19 01:08:27 -05:00
(just_entries (slice (.env_marked x) 0 -2))
(vdict (map (dlambda ((k v)) (array k (recurse v true))) just_entries))
) (add-dict-to-env upper_env vdict))))
(true (error (str "some other strip? " x)))
)
2021-11-22 01:46:59 -05:00
))) (lambda (x) (let* ((_ (print_strip "stripping: " x)) (r (helper x false)) (_ (println "result of strip " r))) r))))
2021-11-16 00:15:53 -05:00
2021-11-23 22:16:24 -05:00
; A bit wild, but what mif instead of is_value we had an evaluation level integer, kinda like wrap?
2021-11-20 01:13:22 -05:00
; when lowering, it could just turn into multiple evals or somesuch, though we'd have to be careful of envs...
(try_unval (rec-lambda recurse (x fail_f)
2021-11-23 22:16:24 -05:00
(cond ((marked_array? x) (mif (not (.marked_array_is_val x)) (array false (fail_f x))
2021-11-20 01:13:22 -05:00
(dlet (((sub_ok subs) (foldl (dlambda ((ok a) x) (dlet (((nok p) (recurse x fail_f)))
(array (and ok nok) (concat a (array p)))))
(array true (array))
(.marked_array_values x))))
2021-11-25 23:57:23 -05:00
(array sub_ok (marked_array false subs)))))
((marked_symbol? x) (mif (.marked_symbol_is_val x) (array true (marked_symbol false (.marked_symbol_value x)))
2021-11-20 01:13:22 -05:00
(array false (fail_f x))))
(true (array true x))
)
))
(try_unval_array (lambda (x) (foldl (dlambda ((ok a) x) (dlet (((nok p) (try_unval x (lambda (_) nil))))
(array (and ok nok) (concat a (array p)))))
(array true (array))
x)))
(ensure_val (rec-lambda recurse (x)
2021-11-25 23:57:23 -05:00
(cond ((marked_array? x) (marked_array true (map recurse (.marked_array_values x))))
((marked_symbol? x) (marked_symbol true (.marked_symbol_value x)))
2021-11-20 01:13:22 -05:00
(true x)
)
))
; This is a conservative analysis, since we can't always tell what constructs introduce
; a new binding scope & would be shadowing... we should at least be able to implement it for
; vau/lambda, but we won't at first
(in_array (let ((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))))
2021-11-23 22:16:24 -05:00
; TODO: make this check for stop envs using de Bruijn indicies
(contains_symbols (rec-lambda recurse (stop_envs symbols x) (cond
((val? x) false)
2021-11-23 22:49:54 -05:00
((marked_symbol? x) (let* ((r (in_array (.marked_symbol_value x) symbols))
(_ (if r (println "!!! contains symbols found " x " in symbols " symbols))))
r))
2021-11-23 22:16:24 -05:00
((marked_array? x) (foldl (lambda (a x) (or a (recurse stop_envs symbols x))) false (.marked_array_values x)))
((comb? x) (dlet (((wrap_level de? se variadic params body) (.comb x)))
(or (recurse stop_envs symbols se) (recurse stop_envs (filter (lambda (y) (not (or (= de? y) (in_array y params)))) symbols) body))))
((prim_comb? x) false)
((marked_env? x) (let ((inner (.env_marked x)))
(cond ((in_array x stop_envs) false)
((foldl (lambda (a x) (or a (recurse stop_envs symbols (idx x 1)))) false (slice inner 0 -2)) true)
((idx inner -1) (recurse stop_envs symbols (idx inner -1)))
(true false))))
(true (error (str "Something odd passed to contains_symbols " x)))
)))
2021-11-20 01:13:22 -05:00
(is_all_values (lambda (evaled_params) (foldl (lambda (a x) (and a (not (later? x)))) true evaled_params)))
2021-11-23 22:16:24 -05:00
; * TODO: allowing envs to be shead mif they're not used.
2021-11-20 01:13:22 -05:00
(shift_envs (rec-lambda recurse (cutoff d x) (cond
((val? x) (array true x))
2021-11-25 23:57:23 -05:00
((marked_env? x) (dlet (((is_real dbi meat) (.marked_env x))
2021-11-20 01:13:22 -05:00
((nmeat_ok nmeat) (foldl (dlambda ((ok r) (k v)) (dlet (((tok tv) (recurse cutoff d v))) (array (and ok tok) (concat r (array (array k tv)))))) (array true (array)) (slice meat 0 -2)))
2021-11-23 22:16:24 -05:00
((nupper_ok nupper) (mif (idx meat -1) (recurse cutoff d (idx meat -1)) (array true nil)))
2021-11-20 01:13:22 -05:00
(ndbi (cond ((nil? dbi) nil)
((>= dbi cutoff) (+ dbi d))
(true dbi)))
2021-11-25 23:57:23 -05:00
) (array (and nmeat_ok nupper_ok (or is_real (and ndbi (>= ndbi 0)))) (marked_env is_real ndbi (concat nmeat (array nupper))))))
2021-11-20 01:13:22 -05:00
((comb? x) (dlet (((wrap_level de? se variadic params body) (.comb x))
((se_ok nse) (recurse cutoff d se))
((body_ok nbody) (recurse (+ cutoff 1) d body))
2021-11-25 23:57:23 -05:00
) (array (and se_ok body_ok) (marked_comb wrap_level de? nse variadic params nbody))))
2021-11-20 01:13:22 -05:00
((prim_comb? x) (array true x))
((marked_symbol? x) (array true x))
((marked_array? x) (dlet (((insides_ok insides) (foldl (dlambda ((ok r) tx) (dlet (((tok tr) (recurse cutoff d tx))) (array (and ok tok) (concat r (array tr))))) (array true (array)) (.marked_array_values x))))
2021-11-25 23:57:23 -05:00
(array insides_ok (marked_array (.marked_array_is_val x) insides))))
2021-11-20 01:13:22 -05:00
(true (error (str "impossible shift_envs value " x)))
)))
(increment_envs (lambda (x) (idx (shift_envs 0 1 x) 1)))
(decrement_envs (lambda (x) (shift_envs 0 -1 x)))
; TODO: instead of returning the later symbols, we could create a new value of a new type
; ['ref de_bruijn_index_of_env index_into_env] or somesuch. Could really simplify
; compiling, and I think make partial-eval more efficient. More accurate closes_over analysis too, I think
(make_tmp_inner_env (lambda (params de? de)
2021-11-25 23:57:23 -05:00
(marked_env false 0 (concat (map (lambda (p) (array p (marked_symbol false p))) params) (mif (= nil de?) (array) (array (array de? (marked_symbol false de?)) )) (array (increment_envs de))))))
2021-11-20 01:13:22 -05:00
(partial_eval_helper (rec-lambda recurse (x env env_stack indent)
(cond ((val? x) x)
((marked_env? x) (let ((dbi (.marked_env_idx x)))
2021-11-23 22:16:24 -05:00
(mif dbi (let* ((new_env (idx env_stack dbi))
2021-11-20 01:13:22 -05:00
(ndbi (.marked_env_idx new_env))
2021-11-23 22:16:24 -05:00
(_ (mif (!= 0 ndbi) (error (str_strip "new env with non-zero dbis " x))))
2021-11-20 01:13:22 -05:00
(_ (println (str_strip "replacing " x) (str_strip " with " new_env)))
)
2021-11-23 22:16:24 -05:00
(mif (= 0 dbi) new_env (idx (shift_envs 0 dbi new_env) 1)))
2021-11-20 01:13:22 -05:00
x)))
((comb? x) (dlet (((wrap_level de? se variadic params body) (.comb x)))
2021-11-23 22:16:24 -05:00
(mif (or (and (not (marked_env_real? env)) (not (marked_env_real? se))) ; both aren't real, re-evaluation of creation site
2021-11-20 01:13:22 -05:00
(and (marked_env_real? env) (not (marked_env_real? se)))) ; new env real, but se isn't - creation!
(let ((inner_env (make_tmp_inner_env params de? env)))
2021-11-25 23:57:23 -05:00
(marked_comb wrap_level de? env variadic params (recurse body inner_env (cons inner_env env_stack) (+ indent 1))))
2021-11-20 01:13:22 -05:00
x)))
((prim_comb? x) x)
2021-11-23 22:16:24 -05:00
((marked_symbol? x) (mif (.marked_symbol_is_val x) x
2021-11-20 01:13:22 -05:00
(env-lookup env (.marked_symbol_value x))))
((marked_array? x) (cond ((.marked_array_is_val x) x)
((= 0 (len (.marked_array_values x))) (error "Partial eval on empty array"))
(true (let* ((values (.marked_array_values x))
(_ (print_strip (indent_str indent) "partial_evaling comb " (idx values 0)))
(comb (recurse (idx values 0) env env_stack (+ 1 indent)))
(literal_params (slice values 1 -1))
(_ (println (indent_str indent) "Going to do an array call!"))
(_ (print_strip (indent_str indent) " total is " x))
(_ (print_strip (indent_str indent) " evaled comb is " comb))
(ident (+ 1 indent))
)
(cond ((prim_comb? comb) ((.prim_comb comb) env env_stack literal_params (+ 1 indent)))
((comb? comb) (dlet (
(rp_eval (lambda (p) (recurse p env env_stack (+ 1 indent))))
((wrap_level de? se variadic params body) (.comb comb))
(ensure_val_params (map ensure_val literal_params))
((ok appropriatly_evaled_params) ((rec-lambda param-recurse (wrap cparams)
2021-11-23 22:16:24 -05:00
(mif (!= 0 wrap)
2021-11-20 01:13:22 -05:00
(dlet ((pre_evaled (map rp_eval cparams))
((ok unval_params) (try_unval_array pre_evaled)))
2021-11-23 22:16:24 -05:00
(mif (not ok) (array ok nil)
2021-11-20 01:13:22 -05:00
(let* ((evaled_params (map rp_eval unval_params)))
(param-recurse (- wrap 1) evaled_params))))
(array true cparams))
) wrap_level ensure_val_params))
(ok_and_non_later (and ok (is_all_values appropriatly_evaled_params)))
2021-11-25 23:57:23 -05:00
) (mif (not ok_and_non_later) (marked_array false (cons comb (mif (> wrap_level 0) (map rp_eval literal_params)
2021-11-20 01:13:22 -05:00
literal_params)))
(dlet (
2021-11-23 22:16:24 -05:00
(final_params (mif variadic (concat (slice appropriatly_evaled_params 0 (- (len params) 1))
2021-11-25 23:57:23 -05:00
(array (marked_array true (slice appropriatly_evaled_params (- (len params) 1) -1))))
2021-11-20 01:13:22 -05:00
appropriatly_evaled_params))
2021-11-23 22:16:24 -05:00
((de_real de_entry) (mif (!= nil de?) (array (marked_env_real? env) (array (array de? (increment_envs env) ) ) )
2021-11-20 01:13:22 -05:00
(array true (array))))
2021-11-25 23:57:23 -05:00
(inner_env (marked_env (and de_real (marked_env_real? se)) 0 (concat (zip params (map (lambda (x) (increment_envs x)) final_params)) de_entry (array (increment_envs se)))))
2021-11-20 01:13:22 -05:00
(_ (print_strip (indent_str indent) " with inner_env is " inner_env))
(_ (print_strip (indent_str indent) "going to eval " body))
(tmp_func_result (recurse body inner_env (cons inner_env env_stack) (+ 1 indent)))
(_ (print_strip (indent_str indent) "evaled result of function call is " tmp_func_result))
((able_to_sub_env func_result) (decrement_envs tmp_func_result))
(result_is_later (later? func_result))
(_ (print_strip (indent_str indent) "success? " able_to_sub_env " decremented result of function call is " tmp_func_result))
2021-11-23 22:16:24 -05:00
(stop_envs ((rec-lambda ser (a e) (mif e (ser (cons e a) (idx (.env_marked e) -1)) a)) (array) se))
(result_closes_over (contains_symbols stop_envs (concat params (mif de? (array de?) (array))) func_result))
2021-11-20 01:13:22 -05:00
(_ (println (indent_str indent) "func call able_to_sub: " able_to_sub_env " result is later? " result_is_later " and result_closes_over " result_closes_over))
; This could be improved to a specialized version of the function
2021-11-23 22:16:24 -05:00
; just by re-wrapping it in a comb instead mif we wanted.
2021-11-20 01:13:22 -05:00
; Something to think about!
2021-11-23 22:16:24 -05:00
(result (mif (or (not able_to_sub_env) (and result_is_later result_closes_over))
2021-11-25 23:57:23 -05:00
(marked_array false (cons comb (mif (> wrap_level 0) (map rp_eval literal_params)
2021-11-20 01:13:22 -05:00
literal_params)))
func_result))
) result))))
2021-11-25 23:57:23 -05:00
((later? comb) (marked_array false (cons comb literal_params)))
2021-11-20 01:13:22 -05:00
(true (error (str "impossible comb value " x))))))))
(true (error (str "impossible partial_eval value " x)))
)
))
2021-11-22 01:28:05 -05:00
; !!!!!!
; ! I think needs_params_val_lambda should be combined with parameters_evaled_proxy
; !!!!!!
(parameters_evaled_proxy (rec-lambda recurse (pasthr_ie inner_f) (lambda (de env_stack params indent) (dlet (
(_ (println "partial_evaling params in parameters_evaled_proxy is " params))
((evaled_params l) (foldl (dlambda ((ac i) p) (let ((p (partial_eval_helper p de env_stack (+ 1 indent))))
(array (concat ac (array p)) (+ i 1))))
(array (array) 0)
params))
) (inner_f (lambda args (apply (recurse pasthr_ie inner_f) args)) de env_stack evaled_params indent)))))
(needs_params_val_lambda_inner (lambda (f_sym actual_function) (let* (
(handler (rec-lambda recurse (de env_stack params indent) (let (
;_ (println "partial_evaling params in need_params_val_lambda for " f_sym " is " params)
(evaled_params (map (lambda (p) (partial_eval_helper p de env_stack (+ 1 indent))) params))
)
2021-11-23 22:16:24 -05:00
(mif (is_all_values evaled_params) (mark (apply actual_function (map strip evaled_params)))
2021-11-25 23:57:23 -05:00
(marked_array false (cons (marked_prim_comb recurse f_sym) evaled_params))))))
) (array f_sym (marked_prim_comb handler f_sym)))))
2021-11-22 01:28:05 -05:00
2021-11-23 01:54:20 -05:00
(give_up_eval_params_inner (lambda (f_sym actual_function) (let* (
(handler (rec-lambda recurse (de env_stack params indent) (let (
;_ (println "partial_evaling params in give_up_eval_params for " f_sym " is " params)
(evaled_params (map (lambda (p) (partial_eval_helper p de env_stack (+ 1 indent))) params))
)
2021-11-25 23:57:23 -05:00
(marked_array false (cons (marked_prim_comb recurse f_sym) evaled_params)))))
) (array f_sym (marked_prim_comb handler f_sym)))))
2021-11-23 01:54:20 -05:00
2021-11-25 23:57:23 -05:00
(root_marked_env (marked_env true nil (array
2021-11-22 01:28:05 -05:00
2021-11-25 23:57:23 -05:00
(array 'vau (marked_prim_comb (rec-lambda recurse (de env_stack params indent) (dlet (
2021-11-23 22:16:24 -05:00
(mde? (mif (= 3 (len params)) (idx params 0) nil))
(vau_mde? (mif (= nil mde?) (array) (array mde?)))
2021-11-23 01:54:20 -05:00
(_ (print "mde? is " mde?))
2021-11-23 22:16:24 -05:00
(_ (print "\tmde? if " (mif mde? #t #f)))
(de? (mif mde? (.marked_symbol_value mde?) nil))
(_ (print "de? is " de?))
(vau_de? (mif (= nil de?) (array) (array de?)))
(raw_marked_params (mif (= nil de?) (idx params 0) (idx params 1)))
(raw_params (map (lambda (x) (mif (not (marked_symbol? x)) (error (str "not a marked symbol " x))
2021-11-22 01:28:05 -05:00
(.marked_symbol_value x))) (.marked_array_values raw_marked_params)))
2021-11-23 22:16:24 -05:00
((variadic vau_params) (foldl (dlambda ((v a) x) (mif (= x '&) (array true a) (array v (concat a (array x))))) (array false (array)) raw_params))
(body (mif (= nil de?) (idx params 1) (idx params 2)))
2021-11-22 01:28:05 -05:00
(inner_env (make_tmp_inner_env vau_params de? de))
(_ (print_strip (indent_str indent) "in vau, evaluating body with 'later params - " body))
(pe_body (partial_eval_helper body inner_env (cons inner_env env_stack) (+ 1 indent)))
(_ (print_strip (indent_str indent) "in vau, result of evaluating body was " pe_body))
2021-11-25 23:57:23 -05:00
) (marked_comb 0 de? de variadic vau_params pe_body)
2021-11-22 01:28:05 -05:00
)) 'vau_fake_real))
2021-11-25 23:57:23 -05:00
(array 'wrap (marked_prim_comb (parameters_evaled_proxy 0 (dlambda (recurse de env_stack (evaled) indent)
2021-11-23 22:16:24 -05:00
(mif (comb? evaled) (dlet (((wrap_level de? se variadic params body) (.comb evaled))
2021-11-25 23:57:23 -05:00
(wrapped_marked_fun (marked_comb (+ 1 wrap_level) de? se variadic params body))
2021-11-22 01:28:05 -05:00
) wrapped_marked_fun)
2021-11-25 23:57:23 -05:00
(marked_array false (array (marked_prim_comb recurse 'wrap_fake_real) evaled))))
2021-11-22 01:28:05 -05:00
) 'wrap_fake_real))
2021-11-25 23:57:23 -05:00
(array 'unwrap (marked_prim_comb (parameters_evaled_proxy 0 (dlambda (recurse de env_stack (evaled) indent)
2021-11-23 22:16:24 -05:00
(mif (comb? evaled) (dlet (((wrap_level de? se variadic params body) (.comb evaled))
2021-11-25 23:57:23 -05:00
(unwrapped_marked_fun (marked_comb (- wrap_level 1) de? se variadic params body))
2021-11-22 01:28:05 -05:00
) unwrapped_marked_fun)
2021-11-25 23:57:23 -05:00
(marked_array false (array (marked_prim_comb recurse 'unwrap_fake_real) evaled))))
2021-11-22 01:28:05 -05:00
) 'unwrap_fake_real))
2021-11-25 23:57:23 -05:00
(array 'eval (marked_prim_comb (rec-lambda recurse (de env_stack params indent) (dlet (
(self (marked_prim_comb recurse 'eval_fake_real))
2021-11-23 22:16:24 -05:00
(eval_env (mif (= 2 (len params)) (partial_eval_helper (idx params 1) de env_stack (+ 1 indent))
2021-11-22 01:28:05 -05:00
de))
2021-11-23 22:16:24 -05:00
(eval_env_v (mif (= 2 (len params)) (array eval_env) (array)))
2021-11-25 23:57:23 -05:00
) (mif (not (marked_env? eval_env)) (marked_array false (cons self params))
2021-11-22 01:28:05 -05:00
(dlet (
(_ (print_strip (indent_str indent) " partial_evaling_body the first time " (idx params 0)))
(body1 (partial_eval_helper (idx params 0) de env_stack (+ 1 indent)))
(_ (print_strip (indent_str indent) "after first eval of param " body1))
; With this, we don't actually fail as this is always a legitimate uneval
2021-11-25 23:57:23 -05:00
(fail_handler (lambda (failed) (marked_array false (concat (array self failed) eval_env_v))))
2021-11-22 01:28:05 -05:00
((ok unval_body) (try_unval body1 fail_handler))
(self_fallback (fail_handler body1))
(_ (print_strip (indent_str indent) "partial_evaling body for the second time in eval " unval_body))
2021-11-23 22:16:24 -05:00
(body2 (mif (= self_fallback unval_body) self_fallback (partial_eval_helper unval_body eval_env env_stack (+ 1 indent))))
2021-11-22 01:28:05 -05:00
(_ (print_strip (indent_str indent) "and body2 is " body2))
) body2))
)) 'eval_fake_real))
;TODO: This could go a lot farther, not stopping after the first 'later, etc
; Also, GAH on odd params - but only one by one - a later odd param can't be imm_eval cuz it will
2021-11-23 22:16:24 -05:00
; be frozen mif an earlier cond is 'later....
2021-11-25 23:57:23 -05:00
(array 'cond (marked_prim_comb (parameters_evaled_proxy nil (lambda (recurse de env_stack evaled_params indent)
2021-11-23 22:16:24 -05:00
(mif (!= 0 (% (len evaled_params) 2)) (error (str "partial eval cond with odd evaled_params " evaled_params))
2021-11-22 01:28:05 -05:00
((rec-lambda recurse_inner (i)
2021-11-25 23:57:23 -05:00
(cond ((later? (idx evaled_params i)) (marked_array false (cons (marked_prim_comb recurse 'cond_fake_real) (slice evaled_params i -1))))
2021-11-22 01:28:05 -05:00
((false? (idx evaled_params i)) (recurse_inner (+ 2 i)))
(true (idx evaled_params (+ 1 i)))) ; we could partially_eval again passing in immediate
2021-11-23 22:16:24 -05:00
; eval mif it was true, to partially counteract the above GAH
2021-11-22 01:28:05 -05:00
) 0)
)
)) 'cond_fake_real))
(needs_params_val_lambda symbol?)
(needs_params_val_lambda int?)
(needs_params_val_lambda string?)
2021-11-25 23:57:23 -05:00
(array 'combiner? (marked_prim_comb (parameters_evaled_proxy nil (dlambda (recurse de env_stack (evaled_param) indent)
(cond ((comb? evaled_param) (marked_val true))
((prim_comb? evaled_param) (marked_val true))
((later? evaled_param) (marked_array false (array (marked_prim_comb recurse 'combinerp_fake_real) evaled_param)))
(true (marked_val false))
2021-11-23 01:54:20 -05:00
)
)) 'combinerp_fake_real))
2021-11-25 23:57:23 -05:00
(array 'env? (marked_prim_comb (parameters_evaled_proxy nil (dlambda (recurse de env_stack (evaled_param) indent)
(cond ((marked_env? evaled_param) (marked_val true))
((later? evaled_param) (marked_array false (array (marked_prim_comb recurse 'envp_fake_real) evaled_param)))
(true (marked_val false))
2021-11-23 01:54:20 -05:00
)
)) 'envp_fake_real))
(needs_params_val_lambda nil?)
(needs_params_val_lambda bool?)
(needs_params_val_lambda str-to-symbol)
(needs_params_val_lambda get-text)
2021-11-25 23:57:23 -05:00
(array 'array? (marked_prim_comb (parameters_evaled_proxy nil (dlambda (recurse de env_stack (evaled_param) indent)
2021-11-23 01:54:20 -05:00
(cond
2021-11-25 23:57:23 -05:00
((later? evaled_param) (marked_array false (array (marked_prim_comb recurse 'arrayp_fake_real) evaled_param)))
((marked_array? evaled_param) (marked_val true))
(true (marked_val false))
2021-11-23 01:54:20 -05:00
)
)) 'arrayp_fake_real))
; This one's sad, might need to come back to it.
; We need to be able to differentiate between half-and-half arrays
; for when we ensure_params_values or whatever, because that's super wrong
2021-11-25 23:57:23 -05:00
(array 'array (marked_prim_comb (parameters_evaled_proxy nil (lambda (recurse de env_stack evaled_params indent)
(mif (is_all_values evaled_params) (marked_array true evaled_params)
(marked_array false (cons (marked_prim_comb recurse 'array_fake_real) evaled_params)))
2021-11-23 01:54:20 -05:00
)) 'array_fake_real))
2021-11-25 23:57:23 -05:00
(array 'len (marked_prim_comb (parameters_evaled_proxy nil (dlambda (recurse de env_stack (evaled_param) indent)
(cond ((later? evaled_param) (marked_array false (array (marked_prim_comb recurse 'len_fake_real) evaled_param)))
((marked_array? evaled_param) (marked_val (len (.marked_array_values evaled_param))))
2021-11-23 01:54:20 -05:00
(true (error (str "bad type to len " evaled_param)))
)
)) 'len_fake_real))
2021-11-25 23:57:23 -05:00
(array 'idx (marked_prim_comb (parameters_evaled_proxy nil (dlambda (recurse de env_stack (evaled_array evaled_idx) indent)
2021-11-23 01:54:20 -05:00
(cond ((and (val? evaled_idx) (marked_array? evaled_array) (.marked_array_is_val evaled_array)) (idx (.marked_array_values evaled_array) (.val evaled_idx)))
2021-11-25 23:57:23 -05:00
(true (marked_array false (array (marked_prim_comb recurse 'idx_fake_real) evaled_array evaled_idx)))
2021-11-23 01:54:20 -05:00
)
)) 'idx_fake_real))
2021-11-25 23:57:23 -05:00
(array 'slice (marked_prim_comb (parameters_evaled_proxy nil (dlambda (recurse de env_stack (evaled_array evaled_begin evaled_end) indent)
2021-11-23 01:54:20 -05:00
(cond ((and (val? evaled_begin) (val? evaled_end) (marked_array? evaled_array) (.marked_array_is_val evaled_array))
2021-11-25 23:57:23 -05:00
(marked_array true (slice (.marked_array_values evaled_array) (.val evaled_begin) (.val evaled_end))))
(true (marked_array false (array (marked_prim_comb recurse 'slice_fake_real) evaled_array evaled_idx evaled_begin evaled_end)))
2021-11-23 01:54:20 -05:00
)
)) 'slice_fake_real))
2021-11-25 23:57:23 -05:00
(array 'concat (marked_prim_comb (parameters_evaled_proxy nil (lambda (recurse de env_stack evaled_params indent)
(cond ((foldl (lambda (a x) (and a (and (marked_array? x) (.marked_array_is_val x)))) true evaled_params) (marked_array true (lapply concat (map (lambda (x)
2021-11-23 01:54:20 -05:00
(.marked_array_values x))
evaled_params))))
2021-11-25 23:57:23 -05:00
(true (marked_array false (cons (marked_prim_comb recurse 'concat_fake_real) evaled_params)))
2021-11-23 01:54:20 -05:00
)
)) 'concat_fake_real))
2021-11-22 01:28:05 -05:00
(needs_params_val_lambda +)
(needs_params_val_lambda -)
(needs_params_val_lambda *)
(needs_params_val_lambda /)
(needs_params_val_lambda %)
;(needs_params_val_lambda &)
;(needs_params_val_lambda |)
;(needs_params_val_lambda <<)
;(needs_params_val_lambda >>)
(needs_params_val_lambda =)
(needs_params_val_lambda !=)
(needs_params_val_lambda <)
(needs_params_val_lambda <=)
(needs_params_val_lambda >)
(needs_params_val_lambda >=)
2021-11-23 01:54:20 -05:00
; these could both be extended to eliminate other known true values except for the end and vice-versa
2021-11-25 23:57:23 -05:00
(array 'and (marked_prim_comb (parameters_evaled_proxy nil (lambda (recurse de env_stack evaled_params indent)
2021-11-23 01:54:20 -05:00
((rec-lambda inner_recurse (i)
(cond ((= i (- (len evaled_params) 1)) (idx evaled_params i))
2021-11-25 23:57:23 -05:00
((later? (idx evaled_params i)) (marked_array false (cons (marked_prim_comb recurse 'and_fake_real) (slice evaled_params i -1))))
2021-11-23 01:54:20 -05:00
((false? (idx evaled_params i)) (idx evaled_params i))
(true (inner_recurse (+ 1 i))))
) 0)
)) 'and_fake_real))
; see above for improvement
2021-11-25 23:57:23 -05:00
(array 'or (marked_prim_comb (parameters_evaled_proxy nil (lambda (recurse de env_stack evaled_params indent)
2021-11-23 01:54:20 -05:00
((rec-lambda inner_recurse (i)
(cond ((= i (- (len evaled_params) 1)) (idx evaled_params i))
2021-11-25 23:57:23 -05:00
((later? (idx evaled_params i)) (marked_array false (cons (marked_prim_comb recurse 'or_fake_real) (slice evaled_params i -1))))
2021-11-23 01:54:20 -05:00
((false? (idx evaled_params i)) (recurse (+ 1 i)))
(true (idx evaled_params i)))
) 0)
)) 'or_fake_real))
; should make not a built in and then do here
; OR not - I think it will actually lower correctly partially evaled
;(needs_params_val_lambda pr-str)
(needs_params_val_lambda str)
;(needs_params_val_lambda prn)
(give_up_eval_params println)
2021-11-23 22:16:24 -05:00
; really do need to figure out mif we want to keep meta, and add it mif so
2021-11-23 01:54:20 -05:00
;(give_up_eval_params meta)
;(give_up_eval_params with-meta)
2021-11-23 22:16:24 -05:00
; mif we want to get fancy, we could do error/recover too
2021-11-23 01:54:20 -05:00
;(give_up_eval_params error)
;(give_up_eval_params recover)
(needs_params_val_lambda read-string)
;(give_up_eval_params slurp)
;(give_up_eval_params get_line)
;(give_up_eval_params write_file)
2021-11-25 23:57:23 -05:00
(array 'empty_env (marked_env true nil (array nil)))
2021-11-23 01:54:20 -05:00
nil
2021-11-22 01:28:05 -05:00
)))
(partial_eval (lambda (x) (partial_eval_helper (mark x) root_marked_env (array) 0)))
2021-11-20 01:13:22 -05:00
2021-11-22 01:28:05 -05:00
(test-all (lambda () (let* (
2021-11-25 23:57:23 -05:00
(run_test (lambda (s) (let* (
(_ (print "\n\ngoing to partial eval " s))
(result (partial_eval (read-string s)))
(_ (print "result of test \"" s "\" => " (str_strip result)))
(_ (print "with a hash of " (.hash result)))
) nil)))
2021-11-22 01:28:05 -05:00
) (begin
2021-11-09 00:35:58 -05:00
(print (val? '(val)))
(print "take 3" (take '(1 2 3 4 5 6 7 8 9 10) 3))
(print "drop 3" (drop '(1 2 3 4 5 6 7 8 9 10) 3))
(print (slice '(1 2 3) 1 2))
(print (slice '(1 2 3) 1 -1))
(print (slice '(1 2 3) -1 -1))
(print (slice '(1 2 3) -2 -1))
2021-11-16 00:15:53 -05:00
(print "ASWDF")
2021-11-19 01:08:27 -05:00
(print ( (dlambda ((a b)) a) '(1337 1338)))
(print ( (dlambda ((a b)) b) '(1337 1338)))
2021-11-16 00:15:53 -05:00
(print (str 1 2 3 (array 1 23 4) "a" "B"))
(print (dlet ( (x 2) ((a b) '(1 2)) (((i i2) i3) '((5 6) 7)) ) (+ x a b i i2 i3)))
2021-11-09 00:35:58 -05:00
(print (array 1 2 3))
(print (command-line-arguments))
(print (call-with-input-string "'(1 2)" (lambda (p) (read p))))
(print (read (open-input-string "'(3 4)")))
2021-11-22 01:28:05 -05:00
2021-11-23 22:16:24 -05:00
(print "mif tests")
(print (mif true 1 2))
(print (mif false 1 2))
(print (mif true 1))
(print (mif false 1))
(print "mif tests end")
(print "zip " (zip '(1 2 3) '(4 5 6) '(7 8 9)))
2021-11-22 01:28:05 -05:00
(print (run_test "(+ 1 2)"))
2021-11-23 01:54:20 -05:00
(print) (print)
(print (run_test "(cond false 1 true 2)"))
(print (run_test "(println 1)"))
(print (run_test "((vau (x) (+ x 1)) 2)"))
2021-11-22 01:28:05 -05:00
2021-11-23 22:49:54 -05:00
(print (run_test "(+ 1 2)"))
(print (run_test "(vau (y) (+ 1 2))"))
(print (run_test "((vau (y) (+ 1 2)) 4)"))
(print (run_test "((vau (y) y) 4)"))
(print (run_test "((vau (y) (+ 13 2 y)) 4)"))
(print (run_test "((wrap (vau (y) (+ 13 2 y))) (+ 3 4))"))
(print (run_test "(vau de (y) (+ (eval y de) (+ 1 2)))"))
(print (run_test "((vau de (y) ((vau dde (z) (+ 1 (eval z dde))) y)) 17)"))
(print (run_test "(cond false 1 false 2 (+ 1 2) 3 true 1337)"))
(print (run_test "(vau de (x) (cond false 1 false 2 x 3 true 42))"))
(print (run_test "(vau de (x) (cond false 1 false 2 3 x true 42))"))
2021-11-24 00:45:44 -05:00
(print (run_test "(combiner? true)"))
(print (run_test "(combiner? (vau de (x) x))"))
(print (run_test "(vau de (x) (combiner? x))"))
(print (run_test "((vau (x) x) a)"))
(print (run_test "(env? true)"))
; this doesn't partially eval, but it could with a more percise if the marked values were more percise
(print (run_test "(vau de (x) (env? de))"))
(print (run_test "(vau de (x) (env? x))"))
(print (run_test "((vau de (x) (env? de)) 1)"))
(print (run_test "((wrap (vau (let1) (let1 a 12 (+ a 1)))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
(print (run_test "((wrap (vau (let1) (let1 a 12 (vau (x) (+ a 1))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
(print (run_test "((wrap (vau (let1) (let1 a 12 (wrap (vau (x) (+ x a 1)))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
(print (run_test "((wrap (vau (let1) (let1 a 12 (wrap (vau (x) (let1 y (+ a 1) (+ y x a))))))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
(print "\n\nlet 4.3\n\n")
(print (run_test "((wrap (vau (let1)
(let1 a 12 (wrap (vau (x) (let1 y (+ a 1) (+ y x a))))
))) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de)))"))
(print "\n\nlet 4.7\n\n")
(print (run_test "((wrap (vau (let1)
(let1 a 12 (wrap (vau (x) (let1 y (+ x a 1) (+ y x a))))
))) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de)))"))
(print "\n\nlet 5\n\n")
(print (run_test "((wrap (vau (let1)
(let1 a 12 (wrap (vau (x) (let1 y (+ x a 1) (+ y x a))))
))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
2021-11-25 23:57:23 -05:00
(print "\n\nlambda 1\n\n")
2021-11-24 00:45:44 -05:00
(print (run_test "((wrap (vau (let1)
(let1 lambda (vau se (p b) (wrap (eval (array vau p b) se)))
(lambda (x) x)
))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
2021-11-25 23:57:23 -05:00
(print "\n\nlambda 2\n\n")
2021-11-24 00:45:44 -05:00
(print (run_test "((wrap (vau (let1)
(let1 lambda (vau se (p b) (wrap (eval (array vau p b) se)))
(let1 a 12
(lambda (x) (+ a x)))
))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
2021-11-25 23:57:23 -05:00
(print "\n\nlambda 3\n\n")
2021-11-24 00:45:44 -05:00
(print (run_test "((wrap (vau (let1)
(let1 lambda (vau se (p b) (wrap (eval (array vau p b) se)))
(let1 a 12
(lambda (x) (let1 b (+ a x)
(+ a x b))))
))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
(print (run_test "(array 1 2 3 4 5)"))
(print (run_test "((wrap (vau (a & rest) rest)) 1 2 3 4 5)"))
2021-11-23 22:49:54 -05:00
2021-11-25 23:57:23 -05:00
;(print "\n\nrecursion test\n\n")
;(print (run_test "((wrap (vau (let1)
; (let1 lambda (vau se (p b) (wrap (eval (array vau p b) se)))
; ((lambda (x n) (x x n)) (lambda (recurse n) (cond n (* n (recurse recurse (- n 1)))
; true 1 )) 5)
; ))) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))"))
2021-11-22 01:28:05 -05:00
))))
2021-11-09 00:35:58 -05:00
) (test-all))
)
