anglican.trap — anglican 1.1.0

CPS transformation of Anglican program

*checkpoint-gensym* clj/s

gensym used to generate checkpoint identifiers, see comment about stable gensym in emit.clj; initially redirects to gensym

*gensym* clj/s

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

*primitive-namespaces* clj/s

functions in these namespaces are primitive

*primitive-procedures* clj/s

primitive procedures, do not exist in CPS form

->observe clj/s≠

(->observe id dist value cont state)

clj

Positional factory function for class anglican.trap.observe.

cljs

Positional factory function for anglican.trap/observe.

->result clj/s≠

(->result state)

clj

Positional factory function for class anglican.trap.result.

cljs

Positional factory function for anglican.trap/result.

->sample clj/s≠

(->sample id dist cont state)

clj

Positional factory function for class anglican.trap.sample.

cljs

Positional factory function for anglican.trap/sample.

adding-primitive-namespaces clj/s macro

(adding-primitive-namespaces names & body)

includes namespaces into the set of primitive namespaces

adding-primitive-procedures clj/s macro

(adding-primitive-procedures names & body)

includes names into the set of primitive procedures

continue clj/s

(continue cont value state)

returns a trampolined call to continuation

cps-of-and clj/s

(cps-of-and args cont)

transforms and to CPS

cps-of-application clj/s

(cps-of-application exprs cont)

transforms application to CPS

cps-of-apply clj/s

(cps-of-apply args cont)

transforms apply to CPS

cps-of-case clj/s

(cps-of-case args cont)

transforms case to CPS

cps-of-catch clj/s

(cps-of-catch args cont)

transforms catch to CPS, delimits code in which values can be thrown using throw with a matching tag

cps-of-cond clj/s

(cps-of-cond clauses cont)

transforms cond to CPS

cps-of-do clj/s

(cps-of-do exprs cont)

transforms do to CPS

cps-of-expression clj/s

(cps-of-expression expr cont)

dispatches CPS transformation by expression type

cps-of-hash-map clj/s

(cps-of-hash-map expr cont)

transforms literal map to CPS

cps-of-if clj/s

(cps-of-if args cont)

transforms if to CPS

cps-of-let clj/s

(cps-of-let args cont)

transforms let to CPS

cps-of-loop clj/s

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

transforms loop

cps-of-observe clj/s

(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/s

(cps-of-opaque expr cont)

transforms opaque expression to CPS

cps-of-or clj/s

(cps-of-or args cont)

transforms or to CPS

cps-of-predict clj/s

(cps-of-predict args cont)

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

cps-of-recur clj/s

(cps-of-recur args cont)

transforms recur

cps-of-retrieve clj/s

(cps-of-retrieve args cont)

transforms retrieve to CPS

cps-of-sample clj/s

(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/s

(cps-of-set expr cont)

transforms literal set to CPS

cps-of-store clj/s

(cps-of-store args cont)

transforms store to CPS; the continuation receives the stored value

cps-of-throw clj/s

(cps-of-throw args _)

transforms throw to CPS, returns to the nearest surrounding catch form with a matching tag

cps-of-vector clj/s

(cps-of-vector expr cont)

transforms literal vector to CPS

cps-of-when clj/s

(cps-of-when args cont)

transforms when to CPS

declaration? clj/s

(declaration? form)

true if the form is a declaration

defn-with-named-cont clj/s macro

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

binds the continuation to a name

fn-cps clj/s

(fn-cps args)

transforms function definition to CPS form

fn-form? clj/s

(fn-form? expr)

true when the argument is a fn form

make-of-args clj/s

(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/s≠

clj

(map->observe m__7585__auto__)

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

cljs

(map->observe G__23176)

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

map->result clj/s≠

clj

(map->result m__7585__auto__)

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

cljs

(map->result G__23204)

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

map->sample clj/s≠

clj

(map->sample m__7585__auto__)

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

cljs

(map->sample G__23190)

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

mem-cps clj/s

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

transforms mem to CPS

mem-form? clj/s

(mem-form? expr)

true when the argument is a mem form

observe cljs

opaque-cps clj/s

(opaque-cps expr)

return CPS form of an opaque expression

opaque? clj/s

(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/s

(primitive-operator? procedure)

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

primitive-procedure-cps clj/s

(primitive-procedure-cps expr)

wraps primitive procedure as a CPS form

primitive-procedure? clj/s

(primitive-procedure? expr)

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

query-cps clj/s

(query-cps args)

transforms nested query into CPS

query-form? clj/s

(query-form? expr)

true when the argument is a mem form

result cljs

result-cont clj/s

(result-cont v s)

sample cljs

shading-primitive-procedures clj/s macro

(shading-primitive-procedures names & body)

excludes names from the set of primitive procedures

simple? clj/s

(simple? expr)

true if expr has no continuation

state-cont clj/s

(state-cont _ s)

returns state

value-cont clj/s

(value-cont v _)

returns value