hyperfiddle.electric.impl.lang3 — com.hyperfiddle/electric v3-alpha-7-gf499d2d1

!a clj

$ clj macro

($ F & args)

->->id clj

(->->id)

->bindlocal-body-e clj

(->bindlocal-body-e ts e)

->bindlocal-value-e clj

(->bindlocal-value-e ts e)

->class-method-call clj

(->class-method-call clazz
                     method
                     method-args
                     pe
                     env
                     form
                     {{:hyperfiddle.electric.impl.lang3/keys [->id]} :o :as ts})

->cljs-env clj

(->cljs-env)

(->cljs-env nssym)

->env-type clj

(->env-type env)

->localv-e clj

(->localv-e ts mklocal-uid)

->obj-method-call clj

(->obj-method-call o
                   method
                   method-args
                   pe
                   env
                   {{:hyperfiddle.electric.impl.lang3/keys [->id]} :o :as ts})

->peer-type clj

(->peer-type env)

->source clj

(->source env root-key efn)

->thunk clj

(->thunk xs)

->ts clj

(->ts)

-expand-all clj

(-expand-all o env)

-expand-all-foreign clj

(-expand-all-foreign o env)

-expand-all-foreign-try clj

(-expand-all-foreign-try o env)

-expand-all-in-try clj

-expand-fn-arity clj

(-expand-fn-arity [bs & body :as o] env)

-expand-let-bindings clj

(-expand-let-bindings bs env)

?add-source-map clj

(?add-source-map {{:hyperfiddle.electric.impl.lang3/keys [->id]} :o :as ts}
                 pe
                 form)

?expand-clj-method-call clj

(?expand-clj-method-call o)

?expand-macro clj

(?expand-macro o env caller)

?get-child-e clj

(?get-child-e ts e)

?meta clj

(?meta metao o)

?untag clj

(?untag sym env)

?update-meta clj

(?update-meta env form)

add-ap-literal clj

(add-ap-literal f
                args
                pe
                e
                env
                {{:hyperfiddle.electric.impl.lang3/keys [->id ->uid]} :o
                 :as ts})

add-foreign-local clj

(add-foreign-local env sym)

add-literal clj

(add-literal {{:hyperfiddle.electric.impl.lang3/keys [->id]} :o :as ts} v e pe)

add-local clj

(add-local env sym)

addf clj

(addf {{:hyperfiddle.electric.impl.lang3/keys [->id]} :o :as ts} u p ->i more)

analyze clj

(analyze form
         pe
         env
         {{:hyperfiddle.electric.impl.lang3/keys [->id ->uid]} :o :as ts})

analyze-clj-symbol clj

(analyze-clj-symbol sym ns$)

analyze-cljs-symbol clj

(analyze-cljs-symbol sym env)

analyze-electric clj

(analyze-electric env
                  {{:hyperfiddle.electric.impl.lang3/keys [->id]} :o :as ts})

analyze-foreign clj

(analyze-foreign form env)

(analyze-foreign {{:hyperfiddle.electric.impl.lang3/keys [->u]} :o :as ts}
                 form
                 env
                 p
                 ->i)

base-js-types clj

bound-js-fn clj

(bound-js-fn sym)

Given a js global resolving to a function (e.g js/alert, js/console.log required-js-ns/js-fn), ensures it is called under the correct this context.

cannot-resolve! clj

(cannot-resolve! env form)

clj-env? clj

(clj-env? env)

cljs-env? clj

(cljs-env? env)

compile clj

(compile nm form env)

compile* clj

(compile* nm env ts)

compute-program-order clj

(compute-program-order ts e)

def-sym-in-cljs-compiler! clj

(def-sym-in-cljs-compiler! sym ns)

delete-point-recursively clj

(delete-point-recursively ts e)

e->uid clj

(e->uid ts e)

electric-env? clj

(electric-env? env)

electric-sym? clj

(electric-sym? sym)

emit clj

(emit ts e ctor-e env nm)

emit-call-init clj

(emit-call-init ts ctor-e e env nm)

emit-ctor clj

(emit-ctor ts ctor-e env nm)

emit-deps clj

(emit-deps ts e)

emit-fn clj

(emit-fn ts e nm)

emit-foreign clj

(emit-foreign ts)

(emit-foreign ts u)

emit-node-init clj

(emit-node-init ts ctor-e node-e env nm)

expand-all clj

(expand-all env o)

expand-macro clj

(expand-macro env o)

fail! clj

(fail! env msg)

(fail! env msg data)

field-access? clj

(field-access? sym)

find-ctor-e clj

(find-ctor-e ts e)

find-local-entry clj

(find-local-entry env sym)

find-sitable-point-e clj

(find-sitable-point-e ts e)

gensym-with-local-meta clj

(gensym-with-local-meta env k)

get-child-e clj

(get-child-e ts e)

get-children-e clj

(get-children-e ts e)

get-local-site clj

(get-local-site ts localv-e)

get-lookup-key clj

(get-lookup-key sym env)

get-node-idx clj

(get-node-idx ts ctor-uid uid)

get-ns clj

(get-ns env)

get-ordered-calls-e clj

(get-ordered-calls-e ts ctor-uid)

get-ordered-ctors-e clj

(get-ordered-ctors-e ts)

get-ordered-nodes-e clj

(get-ordered-nodes-e ts ctor-uid)

get-program-order clj

(get-program-order ts e)

get-ret-e clj

(get-ret-e ts e)

get-root-e clj

(get-root-e ts)

get-site clj

(get-site ts e)

get-them clj

(get-them env)

implicit-cljs-nses clj

implode-point clj

(implode-point ts e)

js-type-hint? clj

(js-type-hint? sym)

js-type? clj

(js-type? sym env)

js-uppercase-sym? clj

(js-uppercase-sym? sym)

jvm-type? clj

(jvm-type? sym)

macroexpand-clj clj

(macroexpand-clj o env)

meta-of-key clj

(meta-of-key mp k)

my-turn? clj

(my-turn? env)

node? clj

(node? mt)

normalize-env clj

(normalize-env env)

ns-qualify clj

(ns-qualify node)

pure-fns clj

qualify-sym clj

(qualify-sym sym env)

reparent-children clj

(reparent-children ts from-e to-e)

resolve-node clj

(resolve-node sym env)

resolve-static-field clj

(resolve-static-field sym)

resolve-symbol clj

(resolve-symbol sym env)

serialized-require clj

(serialized-require sym)

tag-call? clj

(tag-call? ts e)

trace-crumb clj

(trace-crumb o env)

traceable clj

(traceable f)

ts->reducible clj

(ts->reducible ts)

uid->e clj

(uid->e ts uid)

untwin clj

(untwin s)

wrap-foreign-for-electric clj

(wrap-foreign-for-electric ts)

(wrap-foreign-for-electric ts gen)

wrap-point clj

(wrap-point {{:hyperfiddle.electric.impl.lang3/keys [->id]} :o :as ts}
            e
            wrap-nd)