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

Top-level forms for Anglican programs

$comp clj

($comp $cont $state & funs)

comp in CPS

$conditional clj

($conditional cont $state & condargs)

conditional returning CPS-transformed function

$filter clj

($filter $cont $state fun lst)

filter in CPS

$map clj

($map $cont $state fun & lsts)

map in CPS

$map1 clj

($map1 $cont $state fun lst)

map on a single sequence

$nils? clj

($nils? $cont $state lst)

true if the list contains nil

$partial clj

($partial $cont $state fun & bound)

partial in CPS

$reduce clj

($reduce $cont $state fun & args)

reduce in CPS

$reduce1 clj

($reduce1 $cont $state fun init lst)

reduce with explicit init in CPS

$repeatedly clj

($repeatedly $cont $state n thunk)

repeatedly in CPS

$some clj

($some $cont $state fun lst)

some in CPS

anglican clj macro deprecated

(anglican & args)

macro for embedding anglican programs

conditional clj

(conditional query & options)

accepts an Anglican query and returns a conditional distribution defined by the query

cps-fn clj macro deprecated

(cps-fn & args)

legacy name for fm

def-cps-fn clj macro deprecated

(def-cps-fn & args)

legacy name for defm

defanglican clj macro deprecated

(defanglican name & args)

binds variable to anglican program

defm clj macro

(defm name & args)

Binds a variable to an anglican function. The syntax is the same as for `defn' with a single parameter list:

(defm variable-name optional-doc-string [parameter ...]
   anglican-expression ...)

A `defm' declaration is a shortcut for:

(def variable-name optional-doc-string
   (fm variable-name [parameter ...]
       anglican-expression ...))

defquery clj macro

(defquery name & args)

Binds variable to an anglican query. Syntax:

(defquery variable-name optional-doc-string optional-parameter
  anglican-expression ...)

A defquery declaration is a shortcut for

(def variable-name optional-doc-string
  (query optional-parameter
    anglican-expression ...)

defun clj macro deprecated

(defun name & args)

binds variable to function in Anglican syntax

fm clj macro

(fm & args)

Defines an anglican function outside of anglican code. The syntax is the same as of `fn' with a single parameter list:

(fm optional-name [parameter ...] anglican-expression ...)

lambda clj macro deprecated

(lambda & args)

defines function in Anglican syntax

mem clj macro

(mem & args)

creates a memoized computation in CPS form

query clj macro

(query & args)

Defines an anglican query. Syntax:

(query optional-parameter anglican-expression ...)

Example:

(query (let [x (sample (normal 0 10))] (observe (normal 1 1) x) (predict x)))

query' returns a value that can be passed as the second argument toanglican.infer/infer'. An optional parameter can be specified and must either a symbol or a vector, in which case the initial value passed to the query is destructured to the parameter:

(query [mean sd] (let [x (sample (normal mean sd))] (predict x)))

with-primitive-procedures clj macro

(with-primitive-procedures procedures & body)

binds primitive procedure names to their CPS versions; if procedure name is qualified, it becomes unqualified in the scope of the macro