(with_import "./collections.kp" (let ( ; For right now we only support calling partial_eval in such a way that it partial evals against ; the root env, but this is could and really should be extended. We could at least check if the env we're called with ; is the root_env, or if what we look up in whatever env is passed in matches something in the root env ; Care should also be taken when evaluating outside combinators to have them be in the right env, etc ; Here is every form in k' ; True ; False ; Env: *KPEnv ; Combiner: KPCombiner / BuiltinCombiner: KPBuiltinCombiner ; String: str ; Symbol: str ; Int: int ; Array: rc> ; Nil ; Ok, some more things we need / need to change ; 1) meta... ; Honestly, I'm tempted to get rid of it ; Possible marked values ; ['val v] - v is a value that evaluates to itself, and not a combiner or env, as those have their own metadata. Not an array or symbol ; That means it's true/false/a string/ an int/nil ; ['marked_array is_val a] - a contains marked values. if is_val, then it's the value version, and must be stripped back into (array ...), ; otherwise it's a calling form, and should be lowered back to (...). Also, if it's is_val, partial_eval won't perform a call, etc ; ['marked_symbol is_val s] - a symbol. is_val has the same meaning as in marked_array ; ['comb wrap_level de? se variadic params body] - A combiner. Contains the static env and the actual function, if possible. ; It is possible to have a combiner without an actual function, but that's only generated when ; we know it's about to be called and we won't have to strip-lower it ; ['prim_comb ] - A primitive combiner! It has it's own special handler function to partial eval ; ['env is_real [ ['symbol marked_value ]... ]] - A marked env val? (lambda (x) (= 'val (idx x 0))) .val (lambda (x) (idx x 1)) marked_array? (lambda (x) (= 'marked_array (idx x 0))) .marked_array_is_val (lambda (x) (idx x 1)) .marked_array_values (lambda (x) (idx x 2)) marked_symbol? (lambda (x) (= 'marked_symbol (idx x 0))) .marked_symbol_is_val (lambda (x) (idx x 1)) .marked_symbol_value (lambda (x) (idx x 2)) comb? (lambda (x) (= 'comb (idx x 0))) .comb (lambda (x) (slice x 1 -1)) prim_comb? (lambda (x) (= 'prim_comb (idx x 0))) .prim_comb (lambda (x) (idx x 1)) marked_env? (lambda (x) (= 'env (idx x 0))) marked_env_real? (lambda (x) (idx x 1)) .env_marked (lambda (x) (idx x 2)) later? (rec-lambda recurse (x) (or (and (marked_array? x) (= false (.marked_array_is_val x))) (and (marked_symbol? x) (= false (.marked_symbol_is_val x))) (and (marked_env? x) (not (marked_env_real? x))) (and (comb? x) (let ([wrap_level de? se variadic params body] (.comb x) ; this is the complex bit - we should do something like check if ; se is fake check to see if there are symbols or eval that could use it ; or a sub-comb's se, or if de is non-nil and used in some sub-call. comb_is_later (recurse se) ) comb_is_later)) )) false? (lambda (x) (cond (and (marked_array? x) (= false (.marked_array_is_val x))) (error (str "got a later marked_array passed to false? " x)) (and (marked_symbol? x) (= false (.marked_symbol_is_val x))) (error (str "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 (str key " not found in env " (.env_marked env)))) (lambda (x) x))) mark (rec-lambda recurse (x) (cond (env? x) (error (str "called mark with an env " x)) (combiner? x) (error (str "called mark with a combiner " x)) (symbol? x) ['marked_symbol false x] (array? x) ['marked_array false (map recurse x)] true ['val x])) indent_str (rec-lambda recurse (i) (if (= i 0) "" (str " " (recurse (- i 1))))) str_strip (lambda (& args) (lapply str (concat (slice args 0 -2) [((rec-lambda recurse (x) (cond (val? x) (.val x) (marked_array? x) (let (stripped_values (map recurse (.marked_array_values x))) (if (.marked_array_is_val x) (cons array stripped_values) stripped_values)) (marked_symbol? x) (if (.marked_symbol_is_val x) ['quote (.marked_symbol_value x)] (.marked_symbol_value x)) (comb? x) (let ([wrap_level de? se variadic params body] (.comb x)) (str " " params " " (recurse body) ">")) (prim_comb? x) (idx x 2) (marked_env? x) (let (e (.env_marked x) u (idx e -1) ) (if u (str "<" (if (marked_env_real? x) "real" "fake") " ENV " (map (lambda ([k v]) [k (recurse v)]) (slice e 0 -2)) " upper: " (recurse u) ">") "")) true (error (str "some other str_strip? |" x "|")) ) ) (idx args -1))]))) print_strip (lambda (& args) (println (lapply 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))) (if (.marked_array_is_val x) (if need_value (error (str "needed value for this strip but got" x)) (cons array stripped_values)) stripped_values)) (marked_symbol? x) (if (.marked_symbol_is_val x) (if need_value (error (str "needed value for this strip but got" x)) [quote (.marked_symbol_value x)]) (.marked_symbol_value x)) (comb? x) (let ([wrap_level de? se variadic params body] (.comb x) de_entry (if de? [de?] []) final_params (if variadic (concat (slice params 0 -2) '& [(idx params -1)]) params) ; Honestly, could trim down the env to match what could be evaluated in the comb ; Also if this isn't real, lower to a call to vau se_env (if (marked_env_real? se) (recurse se true) nil) body_v (recurse body false) ve (concat [vau] de_entry [final_params] [body_v]) fe ((rec-lambda recurse (x i) (if (= i 0) x (recurse [wrap x] (- i 1)))) ve wrap_level) ) (if se_env (eval fe se_env) fe)) (prim_comb? x) (idx x 2) ; env emitting doesn't pay attention to real value right now, not sure if that makes sense (marked_env? x) (let (_ (if (not (marked_env_real? x)) (error (str_strip "trying to emit fake env!" x))) upper (idx (.env_marked x) -1) upper_env (if upper (recurse upper true) empty_env) just_entries (slice (.env_marked x) 0 -2) vdict (map (lambda ([k v]) [k (recurse v true)]) just_entries) ) (add-dict-to-env upper_env vdict)) true (error (str "some other strip? " x)) ) )) (lambda (x) (let (_ (print_strip "stripping: " x) r (helper x false) _ (println "result of strip " r)) r))) ; A bit wild, but what if instead of is_value we had an evaluation level integer, kinda like wrap? ; 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) (cond (marked_array? x) (if (not (.marked_array_is_val x)) [false (fail_f x)] (let ([sub_ok subs] (foldl (lambda ([ok a] x) (let ([nok p] (recurse x fail_f)) [(and ok nok) (concat a [p])])) [true []] (.marked_array_values x))) [sub_ok ['marked_array false subs]])) (marked_symbol? x) (if (.marked_symbol_is_val x) [true ['marked_symbol false (.marked_symbol_value x)]] [false (fail_f x)]) true [true x] ) ) try_unval_array (lambda (x) (foldl (lambda ([ok a] x) (let ([nok p] (try_unval x (lambda (_) nil))) [(and ok nok) (concat a [p])])) [true []] x)) ensure_val (rec-lambda recurse (x) (cond (marked_array? x) ['marked_array true (map recurse (.marked_array_values x))] (marked_symbol? x) ['marked_symbol true (.marked_symbol_value x)] 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))) contains_symbols (rec-lambda recurse (stop_envs symbols x) (cond (val? x) false (marked_symbol? x) (let (r (in_array (.marked_symbol_value x) symbols) _ (if r (println "!!! contains symbols found " x " in symbols " symbols))) r) (marked_array? x) (foldl (lambda (a x) (or a (recurse stop_envs symbols x))) false (.marked_array_values x)) (comb? x) (let ([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)) )) is_all_values (lambda (evaled_params) (foldl (lambda (a x) (and a (not (later? x)))) true evaled_params)) make_tmp_inner_env (lambda (params de? de) ['env false (concat (map (lambda (p) [p ['marked_symbol false p]]) params) (if (= nil de?) [] [ [de? ['marked_symbol false de?]] ]) [de])]) partial_eval_helper (rec-lambda recurse (x env indent) (cond (val? x) x (marked_env? x) x ;(comb? x) x ; ? this is legal because we don't allow expressions that close over symbols from outer envs to escape those envs, ; so by necessity this is being partially-evaled again in the same environment or sub-environment. ; GAH how do we make sure to avoid capture substitution stuff? ; Need to prevent evaluating calls where parameters close over symbols of the function being called ; or any user-input eval calls, note that we're replacing se below! ; honestly, it seems like we need a way to differentiate between re-partial-evaluating a vau in it's same context but ; with a more accurate environment, and passing around a partially-evaluated comb and calling it (comb? x) (let ([wrap_level de? se variadic params body] (.comb x)) (if (or (and (not (marked_env_real? env)) (not (marked_env_real? se))) ; both aren't real, re-evaluation of creation site (and (marked_env_real? env) (not (marked_env_real? se)))) ; new env real, but se isn't - creation! ['comb wrap_level de? env variadic params (recurse body (make_tmp_inner_env params de? env) (+ indent 1))] x)) (prim_comb? x) x (marked_symbol? x) (if (.marked_symbol_is_val x) x (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) ;_ (println (indent_str indent) "partial_evaling comb " (idx values 0)) _ (print_strip (indent_str indent) "partial_evaling comb " (idx values 0)) comb (recurse (idx values 0) env (+ 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) ) ;;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ;; With our new definition of later?, this prevents combiners without full se's from being called ;;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! (cond (later? comb) ['marked_array false (cons comb literal_params)] (prim_comb? comb) ((.prim_comb comb) env literal_params (+ 1 indent)) (comb? comb) (let ( rp_eval (lambda (p) (recurse p env (+ 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) (if (!= 0 wrap) (let (pre_evaled (map rp_eval cparams) [ok unval_params] (try_unval_array pre_evaled)) (if (not ok) [ok nil] (let (evaled_params (map rp_eval unval_params)) (param-recurse (- wrap 1) evaled_params)))) [true cparams]) ) wrap_level ensure_val_params) ok_and_non_later (and ok (is_all_values appropriatly_evaled_params)) ) (if (not ok_and_non_later) ['marked_array false (cons comb (if (> wrap_level 0) (map rp_eval literal_params) literal_params))] (let ( final_params (if variadic (concat (slice appropriatly_evaled_params 0 (- (len params) 1)) [['marked_array true (slice appropriatly_evaled_params (- (len params) 1) -1)]]) appropriatly_evaled_params) de_entry (if (!= nil de?) [ [de? (if (marked_env_real? env) env ['marked_symbol false de?])] ] []) ;_ (println (indent_str indent) "final_params params " final_params) inner_env ['env (marked_env_real? se) (concat (zip params final_params) de_entry [se])] ;_ (println (indent_str indent) "going to eval " body " with inner_env is " inner_env) _ (print_strip (indent_str indent) " with inner_env is " inner_env) _ (print_strip (indent_str indent) "going to eval " body) func_result (recurse body inner_env (+ 1 indent)) _ (print_strip (indent_str indent) "evaled result of function call is " func_result) result_is_later (later? func_result) stop_envs ((rec-lambda ser (a e) (if e (ser (cons e a) (idx (.env_marked e) -1)) a)) [] se) result_closes_over (contains_symbols stop_envs (concat params (if de? [de?] [])) func_result) _ (println (indent_str indent) "func call result is later? " result_is_later " and result_closes_over " result_closes_over) ; This could be improved to a specialized version of the function ; just by re-wrapping it in a comb instead if we wanted. ; Something to think about! result (if (and result_is_later result_closes_over) ['marked_array false (cons comb (if (> wrap_level 0) (map rp_eval ensure_val_params) literal_params))] func_result) ) result))) true (error (str "Partial eval noticed that you will likely call not a function " comb " total is " x))))) true (error (str "impossible partial_eval value " x)) ) ) needs_params_val_lambda (vau de (f_sym) (let ( actual_function (eval f_sym de) handler (rec-lambda recurse (de 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 (+ 1 indent))) params) ) (if (is_all_values evaled_params) (mark (lapply actual_function (map strip evaled_params))) ['marked_array false (cons ['prim_comb recurse actual_function] evaled_params)]))) ) [f_sym ['prim_comb handler actual_function]])) give_up_eval_params (vau de (f_sym) (let ( actual_function (eval f_sym de) handler (rec-lambda recurse (de 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 (+ 1 indent))) params) ) ['marked_array false (cons ['prim_comb recurse actual_function] evaled_params)])) ) [f_sym ['prim_comb handler actual_function]])) ; !!!!!! ; ! 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 params indent) (let ( _ (println "partial_evaling params in parameters_evaled_proxy is " params) [evaled_params l] (foldl (lambda ([ac i] p) (let (p (partial_eval_helper p de (+ 1 indent))) [(concat ac [p]) (+ i 1)])) [[] 0] params) ) (inner_f (lambda (& args) (lapply (recurse pasthr_ie inner_f) args)) de evaled_params indent)))) root_marked_env ['env true [ ; Ok, so for combinators, it should partial eval the body. ; It should then check to see if the partial-evaled body has closed over ; any 'later values from above the combinator. If so, the combinator should ; evaluate to a ['later [vau de? params (strip partially_evaled_body)]], otherwise it can evaluate to a 'comb. ; Note that this 'later may be re-evaluated later if the parent function is called. ['vau ['prim_comb (rec-lambda recurse (de params indent) (let ( mde? (if (= 3 (len params)) (idx params 0)) vau_mde? (if (= nil mde?) [] [mde?]) de? (if mde? (.marked_symbol_value mde?)) vau_de? (if (= nil de?) [] [de?]) raw_marked_params (if (= nil de?) (idx params 0) (idx params 1)) raw_params (map (lambda (x) (if (not (marked_symbol? x)) (error (str "not a marked symbol " x)) (.marked_symbol_value x))) (.marked_array_values raw_marked_params)) [variadic vau_params] (foldl (lambda ([v a] x) (if (= x '&) [true a] [v (concat a [x])])) [false []] raw_params) body (if (= nil de?) (idx params 1) (idx params 2)) 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 (+ 1 indent)) _ (print_strip (indent_str indent) "in vau, result of evaluating body was " pe_body) _ (print_strip pe_body) ) ['comb 0 de? de variadic vau_params pe_body] )) vau]] ['wrap ['prim_comb (parameters_evaled_proxy 0 (lambda (recurse de [evaled] indent) (if (comb? evaled) (let ([wrap_level de? se variadic params body] (.comb evaled) wrapped_marked_fun ['comb (+ 1 wrap_level) de? se variadic params body] ) wrapped_marked_fun) ['marked_array false [['prim_comb recurse wrap] evaled]])) ) wrap]] ['unwrap ['prim_comb (parameters_evaled_proxy 0 (lambda (recurse de [evaled] indent) (if (comb? evaled) (let ([wrap_level de? se variadic params body] (.comb evaled) unwrapped_marked_fun ['comb (- wrap_level 1) de? se variadic params body] ) unwrapped_marked_fun) ['marked_array false [['prim_comb recurse wrap] evaled]])) ) unwrap]] ['eval ['prim_comb (rec-lambda recurse (de params indent) (let ( self ['prim_comb recurse eval] eval_env (if (= 2 (len params)) (partial_eval_helper (idx params 1) de (+ 1 indent)) de) eval_env_v (if (= 2 (len params)) [eval_env] []) ) (if (not (marked_env? eval_env)) ['marked_array false (cons self params)] (let ( _ (print_strip (indent_str indent) " partial_evaling_body the first time " (idx params 0)) body1 (partial_eval_helper (idx params 0) de (+ 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 fail_handler (lambda (failed) ['marked_array false (concat [self failed] eval_env_v)]) [ok unval_body] (try_unval body1 fail_handler) self_fallback (fail_handler body1) _ (print_strip "partial_evaling body for the second time in eval " unval_body) body2 (if (= self_fallback unval_body) self_fallback (partial_eval_helper unval_body eval_env (+ 1 indent))) _ (print_strip (indent_str indent) "and body2 is " body2) ) body2)) )) eval]] ;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 ; be frozen if an earlier cond is 'later.... ['cond ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de evaled_params indent) (if (!= 0 (% (len evaled_params) 2)) (error (str "partial eval cond with odd evaled_params " evaled_params)) ((rec-lambda recurse_inner (i) (cond (later? (idx evaled_params i)) ['marked_array false (cons ['prim_comb recurse cond] (slice evaled_params i -1))] (false? (idx evaled_params i)) (recurse_inner (+ 2 i)) true (idx evaled_params (+ 1 i))) ; we could partially_eval again passing in immediate ; eval if it was true, to partially counteract the above GAH ) 0) ) )) cond]] (needs_params_val_lambda symbol?) (needs_params_val_lambda int?) (needs_params_val_lambda string?) ; not even a gah, but kinda! ['combiner? ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de [evaled_param] indent) (cond (comb? evaled_param) ['val true] (prim_comb? evaled_param) ['val true] (later? evaled_param) ['marked_array false [['prim_comb recurse combiner?] evaled_param]] true ['val false] ) )) combiner?]] ; not even a gah, but kinda! ['env? ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de [evaled_param] indent) (cond (marked_env? evaled_param) ['val true] (later? evaled_param) ['marked_array false [['prim_comb recurse env?] evaled_param]] true ['val false] ) )) env?]] (needs_params_val_lambda nil?) (needs_params_val_lambda bool?) (needs_params_val_lambda str-to-symbol) (needs_params_val_lambda get-text) ['array? ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de [evaled_param] indent) (cond (later? evaled_param) ['marked_array false [['prim_comb recurse array?] evaled_param]] (marked_array? evaled_param) ['val true] true ['val false] ) )) array?]] ['array ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de evaled_params indent) ['marked_array true evaled_params] )) array]] ['len ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de [evaled_param] indent) (cond (later? evaled_param) ['marked_array false [['prim_comb recurse len] evaled_param]] (marked_array? evaled_param) ['val (len (.marked_array_values evaled_param))] true (error (str "bad type to len " evaled_param)) ) )) len]] ['idx ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de [evaled_array evaled_idx] indent) (cond (and (val? evaled_idx) (marked_array? evaled_array) (.marked_array_is_val evaled_array)) (idx (.marked_array_values evaled_array) (.val evaled_idx)) true ['marked_array false [['prim_comb recurse idx] evaled_array evaled_idx]] ) )) idx]] ['slice ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de [evaled_array evaled_begin evaled_end] indent) (cond (and (val? evaled_begin) (val? evaled_end) (marked_array? evaled_array) (.marked_array_is_val evaled_array)) ['marked_array true (slice (.marked_array_values evaled_array) (.val evaled_begin) (.val evaled_end))] true ['marked_array false [['prim_comb recurse slice] evaled_array evaled_idx evaled_begin evaled_end]] ) )) slice]] ['concat ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de 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) (.marked_array_values x)) evaled_params))] true ['marked_array false (cons ['prim_comb recurse concat] evaled_params)] ) ))) concat]] (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 >=) ; these could both be extended to eliminate other known true values except for the end and vice-versa ['and ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de evaled_params indent) ((rec-lambda inner_recurse (i) (cond (= i (- (len evaled_params) 1)) (idx evaled_params i) (later? (idx evaled_params i)) ['marked_array false (cons ['prim_comb recurse and] (slice evaled_params i -1))] (false? (idx evaled_params i)) (idx evaled_params i) true (inner_recurse (+ 1 i))) ) 0) )) and]] ; see above for improvement ['or ['prim_comb (parameters_evaled_proxy nil (lambda (recurse de evaled_params indent) ((rec-lambda inner_recurse (i) (cond (= i (- (len evaled_params) 1)) (idx evaled_params i) (later? (idx evaled_params i)) ['marked_array false (cons ['prim_comb recurse or] (slice evaled_params i -1))] (false? (idx evaled_params i)) (recurse (+ 1 i)) true (idx evaled_params i)) ) 0) )) or]] ; 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) ; really do need to figure out if we want to keep meta, and add it if so (give_up_eval_params meta) (give_up_eval_params with-meta) ; if we want to get fancy, we could do error/recover too (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) ['empty_env ['env true [nil]]] nil ] root_env] partial_eval (lambda (x) (partial_eval_helper (mark x) root_marked_env 0)) ) (provide partial_eval strip print_strip) ))