anglican.trap — org.clojars.lsaldyt/anglican 1.0.1

CPS transformation of Anglican program

*gensym* clj

customized gensym for code generation, bound to `symbol' in tests

*primitive-namespaces* clj

functions in these namespaces are primitive

*primitive-procedures* clj

primitive procedures, do not exist in CPS form

->observe clj

(->observe id dist value cont state)

Positional factory function for class anglican.trap.observe.

->result clj

(->result state)

Positional factory function for class anglican.trap.result.

->sample clj

(->sample id dist cont state)

Positional factory function for class anglican.trap.sample.

adding-primitive-namespaces clj macro

(adding-primitive-namespaces names & body)

includes namespaces into the set of primitive namespaces

adding-primitive-procedures clj macro

(adding-primitive-procedures names & body)

includes names into the set of primitive procedures

continue clj

(continue cont value state)

returns a trampolined call to continuation

cps-of-and clj

(cps-of-and args cont)

transforms and to CPS

cps-of-application clj

(cps-of-application exprs cont)

transforms application to CPS

cps-of-apply clj

(cps-of-apply args cont)

transforms apply to CPS

cps-of-case clj

(cps-of-case args cont)

transforms case to CPS

cps-of-cond clj

(cps-of-cond clauses cont)

transforms cond to CPS

cps-of-do clj

(cps-of-do exprs cont)

transforms do to CPS

cps-of-expression clj

(cps-of-expression expr cont)

dispatches CPS transformation by expression type

cps-of-hash-map clj

(cps-of-hash-map expr cont)

transforms literal map to CPS

cps-of-if clj

(cps-of-if args cont)

transforms if to CPS

cps-of-let clj

(cps-of-let args cont)

transforms let to CPS

cps-of-loop clj

(cps-of-loop [bindings & body] cont)

transforms loop

cps-of-observe clj

(cps-of-observe args cont)

transforms observe to CPS, observe updates the weight by adding the result of observe (log-probability) to the log-weight

cps-of-opaque clj

(cps-of-opaque expr cont)

transforms opaque expression to CPS

cps-of-or clj

(cps-of-or args cont)

transforms or to CPS

cps-of-predict clj

(cps-of-predict args cont)

transforms predict to CPS, predict appends predicted expression and its value to (:predicts $state)

cps-of-recur clj

(cps-of-recur args cont)

transforms recur

cps-of-retrieve clj

(cps-of-retrieve args cont)

transforms retrieve to CPS

cps-of-sample clj

(cps-of-sample args cont)

transforms sample to CPS; on sample the program is interrupted and the control is transferred to the inference algorithm

cps-of-set clj

(cps-of-set expr cont)

transforms literal set to CPS

cps-of-store clj

(cps-of-store args cont)

transforms store to CPS; the continuation receives the stored value

cps-of-vector clj

(cps-of-vector expr cont)

transforms literal vector to CPS

cps-of-when clj

(cps-of-when args cont)

transforms when to CPS

declaration? clj

(declaration? form)

true if the form is a declaration

defn-with-named-cont clj macro

(defn-with-named-cont cps-of & args)

binds the continuation to a name

fn-cps clj

(fn-cps args)

transforms function definition to CPS form

fn-form? clj

(fn-form? expr)

true when the argument is a fn form

make-of-args clj

(make-of-args args make)

(make-of-args args first-is-rator make)

builds lexical bindings for all compound args and then calls `make' to build expression out of the args; used by predict, observe, sample, application

map->observe clj

(map->observe m__7585__auto__)

Factory function for class anglican.trap.observe, taking a map of keywords to field values.

map->result clj

(map->result m__7585__auto__)

Factory function for class anglican.trap.result, taking a map of keywords to field values.

map->sample clj

(map->sample m__7585__auto__)

Factory function for class anglican.trap.sample, taking a map of keywords to field values.

mem-cps clj

(mem-cps [arg & _ :as args])

transforms mem to CPS

mem-form? clj

(mem-form? expr)

true when the argument is a mem form

opaque-cps clj

(opaque-cps expr)

return CPS form of an opaque expression

opaque? clj

(opaque? expr)

true when the argument is an expression which is passed to continuation (rather than accepts continuation) in its CPS form

primitive-operator? clj

(primitive-operator? procedure)

true if the experssion is converted by clojure to a primitive procedure in operator position

primitive-procedure-cps clj

(primitive-procedure-cps expr)

wraps primitive procedure as a CPS form

primitive-procedure? clj

(primitive-procedure? expr)

true if the expression is primitive, that is, a procedure that does not have a CPS form

query-cps clj

(query-cps args)

transforms nested query into CPS

query-form? clj

(query-form? expr)

true when the argument is a mem form

result-cont clj

(result-cont v s)

shading-primitive-procedures clj macro

(shading-primitive-procedures names & body)

excludes names from the set of primitive procedures

simple? clj

(simple? expr)

true if expr has no continuation

state-cont clj

(state-cont _ s)

returns state

value-cont clj

(value-cont v _)

returns value