anglican.emit — anglican 1.1.0

Top-level forms for Anglican programs

$comp clj/s

($comp $cont $state & funs)

comp in CPS

$conditional clj/s

($conditional cont $state & condargs)

conditional returning CPS-transformed function

$filter clj/s

($filter $cont $state fun lst)

filter in CPS

$map clj/s

($map $cont $state fun & lsts)

map in CPS

$map1 clj/s

($map1 $cont $state fun lst)

map on a single sequence

$nils? clj/s

($nils? $cont $state lst)

true if the list contains nil

$partial clj/s

($partial $cont $state fun & bound)

partial in CPS

$reduce clj/s

($reduce $cont $state fun & args)

reduce in CPS

$reduce1 clj/s

($reduce1 $cont $state fun init lst)

reduce with explicit init in CPS

$repeatedly clj/s

($repeatedly $cont $state n thunk)

repeatedly in CPS

$some clj/s

($some $cont $state fun lst)

some in CPS

anglican clj/s macro deprecated

(anglican & args)

macro for embedding anglican programs

conditional clj/s

(conditional query & options)

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

cps-fn clj/s macro deprecated

(cps-fn & args)

legacy name for fm

def-cps-fn clj/s macro deprecated

(def-cps-fn & args)

legacy name for defm

defanglican clj/s macro deprecated

(defanglican name & args)

binds variable to anglican program

defm clj/s 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/s 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/s macro deprecated

(defun name & args)

binds variable to function in Anglican syntax

fm clj/s 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 ...)

fm* clj/s macro

(fm* name & args)

Helper macro called by fm and defm. The name is mandatory.

fm-fn clj/s

(fm-fn & args)

Function implementing the fm macro, for unit testing.

lambda clj/s macro deprecated

(lambda & args)

defines function in Anglican syntax

mem clj/s macro

(mem & args)

creates a memoized computation in CPS form

query clj/s macro

(query & args)

Defines an anglican query. Syntax:

(query optional-name 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)))

query* clj/s macro

(query* name & args)

Helper macro called by query and defquery. The name is mandatory.

query-fn clj/s

(query-fn & args)

Function implementing the query macro, for unit testing.

with-primitive-procedures clj/s 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