package prbnmcn-dagger

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Core constructs of the DSL

prbnmcn-dagger
- Dagger
  - Cps_monad
    
    Make
    
    Infix
    
    M
    
    Infix
  - Dist
  - Foldable
    
    Make_array
    
    M
    
    Infix
    
    Make_list
    
    M
    
    Infix
    
    Make_seq
    
    M
    
    Infix
  - Identity_monad
    
    M
    
    Infix
  - Incremental_monad
    
    M
    
    Infix
  - Intf
    
    Core
    
    Infix
    
    Foldable
    
    Infix
    
    S
    
    Array_ops
    
    Infix
    
    List_ops
    
    Seq_ops
  - Lmh_incremental_inference
    
    Array_ops
    
    Infix
    
    List_ops
    
    Make_shared
    
    C
    
    Seq_ops
  - Lmh_inference
    
    Array_ops
    
    Infix
    
    List_ops
    
    Seq_ops
  - Log_space
  - RNG
  - Traced_monad
    
    Make
    
    Infix
    
    M
    
    Infix
    
    T
    
    Trace

Legend:
Library
Module
Module type
Parameter
Class
Class type

Module type describing the DSL, implemented by inference backends.

Core constructs of the DSL

include Core

type 'a t

'a t is the type of computations of type 'a

type 'a res

'a res is the outcome of running a computation of type 'a

val return : 'a -> 'a t

return x injects a value x as a computation

val bind : 'a t -> ('a -> 'b t) -> 'b t

Monadic bind

val map : 'a t -> ('a -> 'b) -> 'b t

Functorial map

val map2 : 'a t -> 'b t -> ('a -> 'b -> 'c) -> 'c t

Applicative structure

val map_array : 'a t array -> ('a array -> 'b) -> 'b t

N-array applicative structure

val if_ : bool t -> (bool -> 'a t) -> 'a t

If-then-else, mostly useful for monads featuring incremental computation. Allows to efficiently bind on a boolean computation.

val run : 'a t -> 'a res

Running a monadic computation

module Infix : Infix with type 'a t := 'a t

val sample : 'a Dist.t -> 'a t

sample dist builds a computation that samples from dist. Note that dist must be a pure computation.

val samplei : 'a Dist.t t -> 'a t

samplei dist is similar to sample except that dist can be an impure computation (ie computing the distribution can involve sampling from other distributions).

val map_score : 'a t -> ('a -> float) -> 'a t

map_score m f behaves similarly to m except that the associated computation will be reweighted according to the result of evaluating f on the value of m.

val map_log_score : 'a t -> ('a -> Log_space.t) -> 'a t

Same as map_score excepts that a log-space likelihood is expected.

val score : float -> unit t

score s reweights the computation by s.

val log_score : Log_space.t -> unit t

log_score behaves as score except that a log-space weight is expected.

val stream_samples : 'a t -> RNG.t -> 'a Seq.t

Samples from the posterior described by a computation. Note that calling stream_samples when building a model is incorrect.

module List_ops : Foldable with type 'a t = 'a list and type 'a m := 'a t

module Array_ops : Foldable with type 'a t = 'a array and type 'a m := 'a t

module Seq_ops : Foldable with type 'a t = 'a Seq.t and type 'a m := 'a t