kraken/partial_eval.kp

(with_import "./collections.kp"
(let (
    ; This partial eval only works via the root env,
    ; since we can't tell from outside if something takes an env
    ; or not

    ; Here is every form in k'
    ; True
    ; False
    ; Env: *KPEnv
    ; Combiner: KPCombiner / BuiltinCombiner: KPBuiltinCombiner
    ; String: str
    ; Symbol: str
    ; Int: int
    ; Array: rc<vec<KPValue>>
    ; Nil


    ; Ok, some more things we need / need to change

    ; meta...

    ; Ok, instead of just ['now v] and ['later v], we have these marked values
    ; ['val v] (v can be an array)
    ; ['later c]
    ; ['marked_array a] (a contains marked values)
    ; ['comb wrap_level de? se variadic params body <actual_function>]
    ; ['prim_comb <handler_function> <actual_function>]
    ; ['env [ ['symbol marked_value ]... ] <actual_env>]


    val? (lambda (x) (= 'val (idx x 0)))
    .val (lambda (x) (idx x 1))
    later? (lambda (x) (= 'later (idx x 0)))
    .later (lambda (x) (idx x 1))
    marked_array? (lambda (x) (= 'marked_array (idx x 0)))
    .marked_array (lambda (x) (idx x 1))
    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)))
    .env_marked (lambda (x) (idx x 1))
    .env_real (lambda (x) (idx x 2))

    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 (idx (idx dict i) 1) 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 (idx env 1) key 0 (lambda () (error (str key " not found in env " (idx env 1)))) (lambda (x) 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
    closes_over_var_from_this_env_val (rec-lambda recurse (env body) (cond
        (symbol? body) (env-lookup-helper (concat (slice (idx env 1) 0 -2) [nil]) body 0 (lambda () false) (lambda (x) [body]))
        (array? body)  (foldl (lambda (a x) (or a (recurse env x))) false body)
        true           false))
    closes_over_var_from_this_env_marked (rec-lambda recurse (env x) (cond
              (val? x)          (closes_over_var_from_this_env_val env (.val x))
              (later? x)        (closes_over_var_from_this_env_val env (.later x))
              (marked_array? x) (foldl (lambda (a x) (or a (recurse env x))) false (.marked_array x))
              ; This is where we'd be smart and remove shadowed stuff
              (comb? x)         (let (
                                    [wrap_level de? se variadic params body actual_function] (.comb x)
                                    ; Also this won't work yet because env
                                    (error (str "haven't handled comb yet really either for closes_over_var_from_this_env_marked " x))
                                    ) (or (recurse env se) (recurse env body)))

              (prim_comb? x)    false
              ; Should check to see if the env has anything form env in it, somehow? See if it has this env itself in it?
              (marked_env? x)   (error "haven't handled env in closes_over_var_from_this_env_marked!")
              true              (error (str "Something odd passed to closes_over_var_from_this_env_marked " x))
        ))

    indent_str (rec-lambda recurse (i) (if (= i 0) ""
                                                   (str "   " (recurse (- i 1)))))

    strip (rec-lambda recurse (x)
        (do ;(println "calling strip with " x)
        (cond (val? x)          (.val x) ;(let (v (.val x)) (if (array? v) (cons array (map recurse (map (lambda (x) ['val x]) v))) v))
              (later? x)        (.later x)
              (marked_array? x) (cons array (map recurse (idx x 1)))
              (comb? x)         (let (c (idx x 7))
                                     (if (= nil c) (error (str "partial eval failed: regular stripping a combinator without a real combinator (due to nil enviornment, no doubt)" x))
                                                   c))
              (prim_comb? x)    (idx x 2)
              (marked_env? x)   (error "Env escaped to strip!")
              true              (error (str "some other strip? " x))
        ))
    )

    ; GAH ok additionally
    ; partial_eval_helper will have to deal with combinator values (at least, primitives, I suspect all)
    ; as it might have to use them to reconstruct an expression on strip,
    ; and we will have to partially-eval previously strip'ped expressions when
    ; calling functions whose definition we partially-evaled, etc.
    ; partial_eval_helper always takes in unmarked expressions and makes marked ones, maintaining marked envs
    ;
    ; If indeed we have to keep track of non-primitive combinator values (which I think makes sense for stripping),
    ; we'll have to continually keep a map of values to their definition (we do this now!).

    partial_eval_helper (rec-lambda recurse (x env comb_to_mark_map imm_eval indent)
        (cond   (= x true)                      [comb_to_mark_map ['val true ]]
                (= x false)                     [comb_to_mark_map ['val false]]
                (env? x)                        (error (str "called partial_eval with an env " x))
                (combiner? x)                   [comb_to_mark_map (get-value comb_to_mark_map x)]
                (string? x)                     [comb_to_mark_map ['val x]]
                (symbol? x)                     [comb_to_mark_map (env-lookup env x)]
                (int? x)                        [comb_to_mark_map ['val x]]
                (and (array? x) (= 0 (len x)))  (error "Partial eval on empty array")
                (array? x)                      (let ( [comb_to_mark_map comb] (recurse (idx x 0) env comb_to_mark_map true (+ 1 indent))
                                                       _ (println (indent_str indent) "Going to do an array call!")
                                                       _ (println (indent_str indent) "     total is " x)
                                                       _ (println (indent_str indent) "     evaled comb is  " comb)
                                                       comb (if (val? comb) (get-value comb_to_mark_map (.val comb))
                                                                            comb)
                                                     )
                                                                             ; it seems like even if it's later we should be able to eval some?
                                                                             ; Maybe there should be something between 'later and 'comb made in vau
                                                                             ; for those sorts of cases, but maybe it doesn't matter?
                                                                             ; NOTE: it does matter, and we def need an in between.
                                                                             ; Consider a nested vau "((vau de (y) ((vau dde (z) (+ 1 (eval z dde))) y)) 17)"
                                                                             ; This won't partially evaluate much at all (besides resolving global functions)
                                                                             ; because the inner vau will never evaluate to a comb, since it didn't have a real env
                                                                             ; (because of a bug, actually, MAYYYYYBE we still don't need it?), and thus couldn't then be called
                                                                             ; even though that call would do the evaluation without any real env and would have succeded.
                                                     (cond (later? comb)     [comb_to_mark_map ['later (cons (strip comb) (slice x 1 -1))]]
                                                           (prim_comb? comb) ((.prim_comb comb) env comb_to_mark_map (slice x 1 -1) imm_eval (+ 1 indent))
                                                           (comb? comb)      (let (
                                                                                 [wrap_level de? se variadic params body actual_function] (.comb comb)
                                                                                 literal_params (slice x 1 -1)
                                                                                 [comb_to_mark_map appropriatly_evaled_params] ((rec-lambda param-recurse (wrap params comb_to_mark_map)
                                                                                        (if (!= 0 wrap)
                                                                                            (let ([comb_to_mark_map evaled_params]
                                                                                                                    (foldl (lambda ([comb_to_mark_map ac] p)
                                                                                                                        (let ([comb_to_mark_map p] (recurse p env comb_to_mark_map false (+ 1 indent)))
                                                                                                                              [comb_to_mark_map (concat ac [p])]))
                                                                                                                    [comb_to_mark_map []]
                                                                                                                    (map strip params)))
                                                                                                 (param-recurse (- wrap 1) evaled_params comb_to_mark_map))
                                                                                            [comb_to_mark_map params])
                                                                                            ) wrap_level (map (lambda (p) ['val p]) literal_params) comb_to_mark_map)
                                                                                 final_params (if variadic (concat (slice appropriatly_evaled_params 0 (- (len params) 1))
                                                                                                                   [['marked_array (slice appropriatly_evaled_params (- (len params) 1) -1)]])
                                                                                                           appropriatly_evaled_params)
                                                                                 de_entry (if (!= nil de?) [ [de? env] ] [])
                                                                                 _ (println (indent_str indent) "final_params params " final_params)
                                                                                 de_real_entry (if (!= nil de?) [ [de? (.env_real env)] ] [])
                                                                                 se_real_env (.env_real se)
                                                                                 inner_real_env (if (and se_real_env (or (not de?) (.env_real env)))
                                                                                                    (add-dict-to-env se_real_env
                                                                                                                     (concat (zip params (map strip final_params))
                                                                                                                             de_real_entry))
                                                                                                    nil)
                                                                                 _ (println (indent_str indent) "Inner_real_env is " inner_real_env " because de_real " de_real_entry " se_real_env " se_real_env)
                                                                                 inner_env ['env (concat (zip params final_params) de_entry [se]) inner_real_env]
                                                                                 _ (println (indent_str indent) "going to eval " body " with inner_env is " inner_env)


                                                                                 ; Ok, this might be a later with un-evaled references to parameter symbols,
                                                                                 ; in which case we need to re-wrap up in a vau, since
                                                                                 ; if they're used as parameters to a 'later value that might be a vau,
                                                                                 ; since we don't know if they have to be evaluated and thus
                                                                                 ; can't partially evaluate them.
                                                                                 ; We check with closes_over_var_from_this_env_marked, which can be made more
                                                                                 ; sophisticated, see its definition

                                                                                 [comb_to_mark_map func_result] (recurse body inner_env comb_to_mark_map imm_eval (+ 1 indent))

                                                                                 _ (println (indent_str indent) "evaled result of function call (imm_eval was " imm_eval ")  is " func_result)
                                                                                 result (if (and (later? func_result)
                                                                                                 (closes_over_var_from_this_env_marked inner_env func_result))
                                                                                                                 (if (= nil actual_function)
                                                                                                                        ; this is exponential-y - we retry without imm to see if we can
                                                                                                                        ; have a better partial eval'd later instead of giving up entirely
                                                                                                                        (let ([comb_to_mark_map comb] (recurse (idx x 0) env comb_to_mark_map false (+ 1 indent)))
                                                                                                                            [comb_to_mark_map ['later (cons (strip comb) literal_params)]])
                                                                                                                         [comb_to_mark_map ['later (cons actual_function literal_params)]])
                                                                                                                 [comb_to_mark_map func_result])
                                                                             ) result)
                                                           true              (error (str "Partial eval noticed that you will likely call not a function " comb  " total is " x))))
                (nil? x)                        [comb_to_mark_map ['val x]]
                true                            (error (str "impossible partial_eval value " x))
        )
    )
    is_all_vals (lambda (evaled_params) (foldl (lambda (a x) (and a (val? x))) true evaled_params))
    needs_params_val_lambda (vau de (f_sym) (let (
        actual_function (eval f_sym de)
        handler (lambda (de comb_to_mark_map params imm_eval indent) (let (
                [comb_to_mark_map evaled_params] (foldl (lambda ([comb_to_mark_map evaleds] x) (let (
                                                                     [comb_to_mark_map evaled] (partial_eval_helper x de comb_to_mark_map false (+ 1 indent))
                                                                 ) [comb_to_mark_map (concat evaleds [evaled])])) [comb_to_mark_map []] params)
            )
            (if (is_all_vals evaled_params) [comb_to_mark_map ['val (lapply actual_function (map .val evaled_params))]]
                                            [comb_to_mark_map ['later (cons actual_function (map strip evaled_params))]])))
        ) [f_sym ['prim_comb handler actual_function]]))
    give_up (vau de (f_sym) (let (
        actual_function (eval f_sym de)
        handler (lambda (de comb_to_mark_map params imm_eval indent) [comb_to_mark_map ['later (cons actual_function params)]])
        ) [f_sym ['prim_comb handler actual_function]]))


    parameters_evaled_proxy (lambda (pasthr_ie inner_f) (lambda (de comb_to_mark_map params imm_eval indent) (let (
        [comb_to_mark_map evaled_params l] (foldl (lambda ([comb_to_mark_map ac i] p)
                                                                 (let ([comb_to_mark_map p] (partial_eval_helper p de comb_to_mark_map (if (= i pasthr_ie) imm_eval false) (+ 1 indent)))
                                                                       [comb_to_mark_map (concat ac [p]) (+ i 1)]))
                                                              [comb_to_mark_map [] 0]
                                                              params)
    ) (inner_f de comb_to_mark_map evaled_params imm_eval indent))))

    root_marked_env ['env [
        ; 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 (lambda (de comb_to_mark_map params imm_eval indent) (let (
            de?         (if (= 3 (len params)) (idx params 0))
            vau_de?     (if (= nil de?) [] [de?])
            [variadic vau_params]  (foldl (lambda ([v a] x) (if (= x '&) [true a] [v (concat a [x])])) [false []] (if (= nil de?) (idx params 0) (idx params 1)))
            body        (if (= nil de?) (idx params 1) (idx params 2))
            inner_env   ['env (concat (map (lambda (p) [p ['later p]]) vau_params) (if (= nil de?) [] [ [de? ['later de?]] ]) [de]) nil]
            _ (println (indent_str indent) "in vau, evaluating body with 'later params - " body)
            [comb_to_mark_map pe_body] (partial_eval_helper body inner_env comb_to_mark_map false (+ 1 indent))
            _ (println (indent_str indent) "in vau, result of evaluating body was " pe_body " stripping")
            spe_body (strip pe_body)
            _ (println (indent_str indent) "in vau, result of stripping evaled body was " spe_body)
            for_later (= nil (.env_real de))
            _ (println (indent_str indent) "imm_eval is " imm_eval " and for_later is " for_later " for " params " because of env being null " de)
        ) (if for_later (if (not imm_eval) [comb_to_mark_map ['later (concat [vau] vau_de? [vau_params spe_body])]]
                                           [comb_to_mark_map ['comb 0 de? de variadic vau_params spe_body nil]])
                        (let (real_func (eval (concat [vau] vau_de? [vau_params spe_body]) (.env_real de))
                              marked_func ['comb 0 de? de variadic vau_params spe_body real_func]
                              _ (println (indent_str indent) "Marked func is " marked_func)
                             ) [(put comb_to_mark_map real_func marked_func) marked_func])))
        ) vau]]

        ['wrap ['prim_comb (parameters_evaled_proxy 0 (lambda (de comb_to_mark_map [evaled] imm_eval indent)
              (if (comb? evaled) (let ([wrap_level de? se variadic params body actual_function] (.comb evaled)
                                        wrapped_actual_fun (if (= nil actual_function) nil (wrap actual_function))
                                        wrapped_marked_fun ['comb (+ 1 wrap_level) de? se variadic params body wrapped_actual_fun]
                                      ) [(put comb_to_mark_map wrapped_actual_fun wrapped_marked_fun) wrapped_marked_fun])
                                 [comb_to_mark_map ['later [wrap (strip evaled)]]]))
        ) wrap]]
        ['unwrap ['prim_comb (parameters_evaled_proxy 0 (lambda (de comb_to_mark_map [evaled] imm_eval indent)
             (if (comb? evaled) (let ([wrap_level de? se variadic params body actual_function] (.comb evaled)
                                        unwrapped_actual_fun (if (= nil actual_function) nil (unwrap actual_function))
                                        unwrapped_marked_fun ['comb (- wrap_level 1) de? se variadic params body unwrapped_actual_fun]
                                      ) [(put comb_to_mark_map unwrapped_actual_fun unwrapped_marked_fun) unwrapped_marked_fun])
                                 [comb_to_mark_map ['later [unwrap (strip evaled)]]]))
        ) unwrap]]

        ['eval ['prim_comb (lambda (de comb_to_mark_map params imm_eval indent) (let (
            [comb_to_mark_map eval_env] (if (= 2 (len params)) (partial_eval_helper (idx params 1) de comb_to_mark_map false (+ 1 indent))
                                                               [comb_to_mark_map de])
         ) (if (not (marked_env? eval_env)) [comb_to_mark_map ['later (cons eval params)]]
                                            (let (
            _ (println (indent_str indent) "ok, env was " eval_env)
            [comb_to_mark_map body1] (partial_eval_helper (idx params 0) de comb_to_mark_map imm_eval (+ 1 indent))
            _ (println (indent_str indent) "after first eval of param " body1)

            ;;;;
            ;; TODO: add a terrible hack (I was thinking about some sort of value to embed a non-real combiner into the stripped that will be turned back in partial eval
            ;; but we'd have to be careful to also remove it on this side, and what about if it gets wrapped in another combiner? Maybe just a bad idea
            ;;;;
            terrible_hack_strip (rec-lambda recurse (x)
                (cond (val? x)          [true (.val x)]
                      (later? x)        [false (.later x)]
                      (marked_array? x) (foldl (lambda ([ok a] x) (let ([nok p] (recurse x))
                                                                        [(and ok nok) (concat a [p])]))
                                               [true []]
                                               (idx x 1))
                      (comb? x)         (let (c (idx x 7))
                                             (if (= nil c) (error (str "partial eval failed: inne stripping a combinator without a real combinator (due to nil enviornment, no doubt)" x))
                                                           [true c]))
                      (prim_comb? x)    [true (idx x 2)]
                      (marked_env? x)   (error "Env escaped to strip!")
                      true              (error (str "some other strip? " x))
                )
            )

            fallback_result [comb_to_mark_map ['later [eval (.later body1) (if (= nil (.env_real eval_env)) (slice params 1 -1) (.env_real eval_env))]]]
            c_body2 (cond (val? body1)      (partial_eval_helper (.val body1) eval_env comb_to_mark_map imm_eval (+ 1 indent))
                      (later? body1)        fallback_result
                      ; In the case of a later value internal to marked_array, it must finish being evaluated, or at least kept as a later
                      (marked_array? body1) (let ([ok sbody1] (terrible_hack_strip body1))
                                                 (if ok (partial_eval_helper sbody1 eval_env comb_to_mark_map imm_eval (+ 1 indent))
                                                        fallback_result))
                      (comb? body1)         [comb_to_mark_map body1]
                      (prim_comb? body1)    [comb_to_mark_map body1]
                      (marked_env? body1)   (error "Env escaped to eval_strip!")
                      true              (error (str "some other eval_strip? " body1))
                )
            _ (println (indent_str indent) "and body2 is " (idx c_body2 1))
            ) c_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 (de comb_to_mark_map evaled_params imm_eval indent)
            (if (!= 0 (% (len evaled_params) 2)) (error (str "partial eval cond with odd evaled_params " evaled_params))
                ((rec-lambda recurse (i)
                                          (cond (later? (idx evaled_params i))           [comb_to_mark_map ['later (cons cond (slice (map strip evaled_params) i -1))]]
                                                (and (val? (idx evaled_params i))
                                                     (not (.val (idx evaled_params i)))) (recurse (+ 2 i))
                                                true                                     [comb_to_mark_map (idx evaled_params (+ 1 i))])
                 ) 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 (de comb_to_mark_map [evaled_param] imm_eval indent)
            (cond (val? evaled_param)       [comb_to_mark_map ['val (combiner? (.val evaled_param))]]
                  (comb? evaled_param)      [comb_to_mark_map ['val true]]
                  (prim_comb? evaled_param) [comb_to_mark_map ['val true]]
                  (later? evaled_param)     [comb_to_mark_map ['later [combiner? (strip evaled_param)]]]
                  true                      [comb_to_mark_map ['val false]]
            )
        )) combiner?]]
        ; not even a gah, but kinda!
        ['env? ['prim_comb (parameters_evaled_proxy nil (lambda (de comb_to_mark_map [evaled_param] imm_eval indent)
            (cond (val? evaled_param)           [comb_to_mark_map ['val (env? (.val evaled_param))]]
                  (marked_env? evaled_param)    [comb_to_mark_map ['val true]]
                  (later? evaled_param)         [comb_to_mark_map ['later [env? (strip evaled_param)]]]
                  true                          [comb_to_mark_map ['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 (de comb_to_mark_map [evaled_param] imm_eval indent)
            (cond (val? evaled_param)           [comb_to_mark_map ['val (array? (.val evaled_param))]]
                  (marked_array? evaled_param)    [comb_to_mark_map ['val true]]
                  (later? evaled_param)         [comb_to_mark_map ['later [array? (strip evaled_param)]]]
                  true                          [comb_to_mark_map ['val false]]
            )
        )) array?]]
        ['array ['prim_comb (parameters_evaled_proxy nil (lambda (de comb_to_mark_map evaled_params imm_eval indent)
            (if (is_all_vals evaled_params)     [comb_to_mark_map ['val (map strip evaled_params)]]
                                                [comb_to_mark_map ['marked_array evaled_params]]
            )
        )) array]]
        ['len ['prim_comb (parameters_evaled_proxy nil (lambda (de comb_to_mark_map [evaled_param] imm_eval indent)
            (cond (val? evaled_param)           [comb_to_mark_map ['val (len (.val evaled_param))]]
                  (marked_array? evaled_param)  [comb_to_mark_map ['val (len (.marked_array evaled_param))]]
                  true                          [comb_to_mark_map ['later [len (strip evaled_param)]]]
            )
        )) len]]
        ['idx ['prim_comb (parameters_evaled_proxy nil (lambda (de comb_to_mark_map [evaled_array evaled_idx] imm_eval indent)
            (cond (and (val? evaled_idx) (val? evaled_array))             [comb_to_mark_map ['val (idx (.val evaled_array) (.val evaled_idx))]]
                  (and (val? evaled_idx) (marked_array? evaled_array))    [comb_to_mark_map       (idx (.marked_array evaled_array) (.val evaled_idx))]
                  true                                                    [comb_to_mark_map ['later [idx (strip evaled_array) (strip evaled_idx)]]]
            )
        )) idx]]
        ['slice ['prim_comb (parameters_evaled_proxy nil (lambda (de comb_to_mark_map [evaled_array evaled_begin evaled_end] imm_eval indent)
            (cond (and (val? evaled_begin) (val? evaled_end) (val? evaled_array))             [comb_to_mark_map ['val (slice (.val evaled_array) (.val evaled_begin) (.val evaled_end))]]
                  (and (val? evaled_begin) (val? evaled_end) (marked_array? evaled_array))    [comb_to_mark_map ['marked_array (slice (.marked_array evaled_array)
                                                                                                                                      (.val evaled_begin)
                                                                                                                                      (.val evaled_end))]]
                  true                                                                        [comb_to_mark_map ['later [slice (strip evaled_array)
                                                                                                                               (strip evaled_begin)
                                                                                                                               (strip evaled_end)]]]
            )
        )) slice]]
        ['concat ['prim_comb (parameters_evaled_proxy nil (lambda (de comb_to_mark_map evaled_params imm_eval indent)
            (cond (foldl (lambda (a x) (and a (val? x))) true evaled_params)                           [comb_to_mark_map ['val (lapply concat (map strip evaled_params))]]
                  (foldl (lambda (a x) (and a (or (val? x) (marked_array? x)))) true evaled_params)    [comb_to_mark_map ['marked_array (lapply concat (map (lambda (x)
                                                                                                                            (if (val? x) (map (lambda (y) ['val y]) (.val x))
                                                                                                                                         (.marked_array x))
                                                                                                                                                            ) evaled_params))]]
                  true                                                                                 [comb_to_mark_map ['later (cons concat (map strip 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 >=)

        ['and ['prim_comb (parameters_evaled_proxy nil (lambda (de comb_to_mark_map evaled_params imm_eval indent)
            ((rec-lambda recurse (i)
                                      (cond (= i (- (len evaled_params) 1))          [comb_to_mark_map (idx evaled_params i)]
                                            (later? (idx evaled_params i))           [comb_to_mark_map ['later (cons and (slice (map strip evaled_params) i -1))]]
                                            (and (val? (idx evaled_params i))
                                                 (not (.val (idx evaled_params i)))) [comb_to_mark_map (idx evaled_params i)]
                                            true                                     (recurse (+ 1 i)))
             ) 0)
        )) and]]
        ['or ['prim_comb (parameters_evaled_proxy nil (lambda (de comb_to_mark_map evaled_params imm_eval indent)
            ((rec-lambda recurse (i)
                                      (cond (= i (- (len evaled_params) 1))          [comb_to_mark_map (idx evaled_params i)]
                                            (later? (idx evaled_params i))           [comb_to_mark_map ['later (cons or (slice (map strip evaled_params) i -1))]]
                                            (and (val? (idx evaled_params i))
                                                 (not (.val (idx evaled_params i)))) (recurse (+ 1 i))
                                            true                                     [comb_to_mark_map (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 println)
        ; really do need to figure out if we want to keep meta, and add it if so
        (give_up meta)
        (give_up with-meta)
        ; if we want to get fancy, we could do error/recover too
        (give_up error)
        (give_up recover)
        (needs_params_val_lambda read-string)
        (give_up slurp)
        (give_up get_line)
        (give_up write_file)
        ['empty_env ['env [] empty_env]]
        nil
    ] root_env]

    comb_to_mark_map (foldl (lambda (a x) (cond (= nil x)              a
                                                (comb?      (idx x 1)) (put a (idx (idx x 1) 6) (idx x 1))
                                                (prim_comb? (idx x 1)) (put a (idx (idx x 1) 2) (idx x 1))
                                                true                   a
                                          ) ) empty_dict (idx root_marked_env 1))
    partial_eval (lambda (x) (partial_eval_helper x root_marked_env comb_to_mark_map false 0))
)
    (provide partial_eval strip)
))