{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MonoLocalBinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}

{- | An algebraic effect embedding of probabilistic models.
-}

module Model (
    Model(..)
  , handleCore
    -- * Distribution smart constructors
    -- $Smart-Constructors
  , bernoulli
  , bernoulli'
  , beta
  , beta'
  , binomial
  , binomial'
  , categorical
  , categorical'
  , cauchy
  , cauchy'
  , halfCauchy
  , halfCauchy'
  , deterministic
  , deterministic'
  , dirichlet
  , dirichlet'
  , discrete
  , discrete'
  , gamma
  , gamma'
  , normal
  , normal'
  , halfNormal
  , halfNormal'
  , poisson
  , poisson'
  , uniform
  , uniform'
  )
  where

import Control.Monad ( ap )
import Control.Monad.Trans.Class ( MonadTrans(lift) )
import Effects.Dist ( handleDist, Dist(Dist), Observe, Sample )
import Effects.Lift ( Lift(..) )
import Effects.ObsReader ( ask, handleRead, ObsReader )
import Effects.State ( State, modify, handleState )
import Env ( varToStr, Env, ObsVar, Observable )
import PrimDist ( PrimVal, PrimDist(..) )
import Prog ( call, Member, Prog )
import qualified OpenSum

{- | Models are parameterised by:

    1) a model environment @env@ containing random variables that can be provided observed values

    2) an effect signature @es@ of the possible effects a model can invoke

    3) an output type @a@ of values that the model generates.

    A model initially consists of (at least) two effects: @Dist@ for calling primitive distributions
    and @ObsReader env@ for reading from @env@.
-}
newtype Model env es a =
  Model { forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
Model env es a
-> (Member Dist es, Member (ObsReader env) es) => Prog es a
runModel :: (Member Dist es, Member (ObsReader env) es) => Prog es a }
  deriving (forall a b. (a -> b) -> Model env es a -> Model env es b)
-> (forall a b. a -> Model env es b -> Model env es a)
-> Functor (Model env es)
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a b.
a -> Model env es b -> Model env es a
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a b.
(a -> b) -> Model env es a -> Model env es b
forall a b. a -> Model env es b -> Model env es a
forall a b. (a -> b) -> Model env es a -> Model env es b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Model env es b -> Model env es a
$c<$ :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a b.
a -> Model env es b -> Model env es a
fmap :: forall a b. (a -> b) -> Model env es a -> Model env es b
$cfmap :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a b.
(a -> b) -> Model env es a -> Model env es b
Functor

instance Applicative (Model env es) where
  pure :: forall a. a -> Model env es a
pure a
x = ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es a)
 -> Model env es a)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall a b. (a -> b) -> a -> b
$ a -> Prog es a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x
  <*> :: forall a b.
Model env es (a -> b) -> Model env es a -> Model env es b
(<*>) = Model env es (a -> b) -> Model env es a -> Model env es b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap

instance Monad (Model env es) where
  return :: forall a. a -> Model env es a
return = a -> Model env es a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  Model (Member Dist es, Member (ObsReader env) es) => Prog es a
f >>= :: forall a b.
Model env es a -> (a -> Model env es b) -> Model env es b
>>= a -> Model env es b
x = ((Member Dist es, Member (ObsReader env) es) => Prog es b)
-> Model env es b
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es b)
 -> Model env es b)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es b)
-> Model env es b
forall a b. (a -> b) -> a -> b
$ do
    a
f' <- Prog es a
(Member Dist es, Member (ObsReader env) es) => Prog es a
f
    Model env es b -> Prog es b
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
Model env es a
-> (Member Dist es, Member (ObsReader env) es) => Prog es a
runModel (Model env es b -> Prog es b) -> Model env es b -> Prog es b
forall a b. (a -> b) -> a -> b
$ a -> Model env es b
x a
f'

{- | The initial handler for models, specialising a model under a certain
environment to produce a probabilistic program consisting of @Sample@ and @Observe@ operations. -}
handleCore :: (Member Observe es, Member Sample es) => Env env -> Model env (ObsReader env : Dist : es) a -> Prog es a
handleCore :: forall (es :: [* -> *]) (env :: [Assign Symbol (*)]) a.
(Member Observe es, Member Sample es) =>
Env env -> Model env (ObsReader env : Dist : es) a -> Prog es a
handleCore Env env
env Model env (ObsReader env : Dist : es) a
m = (Prog (Dist : es) a -> Prog es a
forall (es :: [* -> *]) a.
(Member Sample es, Member Observe es) =>
Prog (Dist : es) a -> Prog es a
handleDist (Prog (Dist : es) a -> Prog es a)
-> (Prog (ObsReader env : Dist : es) a -> Prog (Dist : es) a)
-> Prog (ObsReader env : Dist : es) a
-> Prog es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Env env -> Prog (ObsReader env : Dist : es) a -> Prog (Dist : es) a
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
Env env -> Prog (ObsReader env : es) a -> Prog es a
handleRead Env env
env) (Model env (ObsReader env : Dist : es) a
-> (Member Dist (ObsReader env : Dist : es),
    Member (ObsReader env) (ObsReader env : Dist : es)) =>
   Prog (ObsReader env : Dist : es) a
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
Model env es a
-> (Member Dist es, Member (ObsReader env) es) => Prog es a
runModel Model env (ObsReader env : Dist : es) a
m)

{- $Smart-Constructors

    Smart constructors for calling primitive distribution operations inside models,
    where each distribution comes with a primed and an unprimed variant.

    An unprimed distribution takes the standard distribution parameters as well as
    an observable variable. This lets one later provide observed values for that
    variable to be conditioned against:

    @
    exampleModel :: Observable env "b" Bool => Model env es Bool
    exampleModel = bernoulli 0.5 #b
    @

    A primed distribution takes no observable variable and so cannot be conditioned against;
    this will always representing sampling from that distribution:

    @
    exampleModel' :: Model env es Bool
    exampleModel' = bernoulli' 0.5
    @
-}

deterministic :: forall env es a x. (Eq a, Show a, OpenSum.Member a PrimVal, Observable env x a) => a
  -> ObsVar x
  -> Model env es a
deterministic :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a
       (x :: Symbol).
(Eq a, Show a, Member a PrimVal, Observable env x a) =>
a -> ObsVar x -> Model env es a
deterministic a
x ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es a)
 -> Model env es a)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe a
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist a -> Prog es a
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist a -> Maybe a -> Maybe String -> Dist a
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (a -> PrimDist a
forall a. (Eq a, Show a, Member a PrimVal) => a -> PrimDist a
DeterministicDist a
x) Maybe a
maybe_y Maybe String
tag)

deterministic' :: (Eq a, Show a, OpenSum.Member a PrimVal) =>
  -- | value to be deterministically generated
     a
  -> Model env es a
deterministic' :: forall a (env :: [Assign Symbol (*)]) (es :: [* -> *]).
(Eq a, Show a, Member a PrimVal) =>
a -> Model env es a
deterministic' a
x = ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es a)
 -> Model env es a)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall a b. (a -> b) -> a -> b
$ do
  Dist a -> Prog es a
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist a -> Maybe a -> Maybe String -> Dist a
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (a -> PrimDist a
forall a. (Eq a, Show a, Member a PrimVal) => a -> PrimDist a
DeterministicDist a
x) Maybe a
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

dirichlet :: forall env es x. Observable env x [Double] =>
     [Double]
  -> ObsVar x
  -> Model env es [Double]
dirichlet :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x [Double] =>
[Double] -> ObsVar x -> Model env es [Double]
dirichlet [Double]
xs ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es [Double])
-> Model env es [Double]
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es [Double])
 -> Model env es [Double])
-> ((Member Dist es, Member (ObsReader env) es) =>
    Prog es [Double])
-> Model env es [Double]
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe [Double]
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist [Double] -> Prog es [Double]
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist [Double]
-> Maybe [Double] -> Maybe String -> Dist [Double]
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist ([Double] -> PrimDist [Double]
DirichletDist [Double]
xs) Maybe [Double]
maybe_y Maybe String
tag)

dirichlet' ::
  -- | concentration parameters
     [Double]
  -> Model env es [Double]
dirichlet' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
[Double] -> Model env es [Double]
dirichlet' [Double]
xs = ((Member Dist es, Member (ObsReader env) es) => Prog es [Double])
-> Model env es [Double]
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es [Double])
 -> Model env es [Double])
-> ((Member Dist es, Member (ObsReader env) es) =>
    Prog es [Double])
-> Model env es [Double]
forall a b. (a -> b) -> a -> b
$ do
  Dist [Double] -> Prog es [Double]
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist [Double]
-> Maybe [Double] -> Maybe String -> Dist [Double]
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist ([Double] -> PrimDist [Double]
DirichletDist [Double]
xs) Maybe [Double]
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

discrete :: forall env es x. Observable env x Int =>
     [Double]
  -> ObsVar x
  -> Model env es Int
discrete :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Int =>
[Double] -> ObsVar x -> Model env es Int
discrete [Double]
ps ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Int)
 -> Model env es Int)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Int
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Int -> Prog es Int
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Int -> Maybe Int -> Maybe String -> Dist Int
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist ([Double] -> PrimDist Int
DiscreteDist [Double]
ps) Maybe Int
maybe_y Maybe String
tag)

discrete' ::
  -- | list of @n@ probabilities
     [Double]
  -- | integer index from @0@ to @n - 1@
  -> Model env es Int
discrete' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
[Double] -> Model env es Int
discrete' [Double]
ps = ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Int)
 -> Model env es Int)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall a b. (a -> b) -> a -> b
$ do
  Dist Int -> Prog es Int
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Int -> Maybe Int -> Maybe String -> Dist Int
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist ([Double] -> PrimDist Int
DiscreteDist [Double]
ps) Maybe Int
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

categorical :: forall env es a x. (Eq a, Show a, OpenSum.Member a PrimVal, Observable env x a) =>
     [(a, Double)]
  -> ObsVar x
  -> Model env es a
categorical :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a
       (x :: Symbol).
(Eq a, Show a, Member a PrimVal, Observable env x a) =>
[(a, Double)] -> ObsVar x -> Model env es a
categorical [(a, Double)]
xs ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es a)
 -> Model env es a)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe a
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist a -> Prog es a
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist a -> Maybe a -> Maybe String -> Dist a
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist ([(a, Double)] -> PrimDist a
forall a.
(Eq a, Show a, Member a PrimVal) =>
[(a, Double)] -> PrimDist a
CategoricalDist [(a, Double)]
xs) Maybe a
maybe_y Maybe String
tag)

categorical' :: (Eq a, Show a, OpenSum.Member a PrimVal) =>
  -- | primitive values and their probabilities
     [(a, Double)]
  -> Model env es a
categorical' :: forall a (env :: [Assign Symbol (*)]) (es :: [* -> *]).
(Eq a, Show a, Member a PrimVal) =>
[(a, Double)] -> Model env es a
categorical' [(a, Double)]
xs = ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es a)
 -> Model env es a)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
forall a b. (a -> b) -> a -> b
$ do
  Dist a -> Prog es a
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist a -> Maybe a -> Maybe String -> Dist a
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist ([(a, Double)] -> PrimDist a
forall a.
(Eq a, Show a, Member a PrimVal) =>
[(a, Double)] -> PrimDist a
CategoricalDist [(a, Double)]
xs) Maybe a
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

normal :: forall env es x. Observable env x Double =>
     Double
  -> Double
  -> ObsVar x
  -> Model env es Double
normal :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Double =>
Double -> Double -> ObsVar x -> Model env es Double
normal Double
mu Double
sigma ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Double
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
NormalDist Double
mu Double
sigma) Maybe Double
maybe_y Maybe String
tag)

normal' ::
  -- | mean
     Double
  -- | standard deviation
  -> Double
  -> Model env es Double
normal' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Double -> Model env es Double
normal' Double
mu Double
sigma = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
NormalDist Double
mu Double
sigma) Maybe Double
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

halfNormal :: forall env es x. Observable env x Double =>
     Double
  -> ObsVar x
  -> Model env es Double
halfNormal :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Double =>
Double -> ObsVar x -> Model env es Double
halfNormal Double
sigma ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Double
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> PrimDist Double
HalfNormalDist Double
sigma) Maybe Double
maybe_y Maybe String
tag)

halfNormal' ::
  -- | standard deviation
     Double
  -> Model env es Double
halfNormal' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Model env es Double
halfNormal' Double
sigma = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> PrimDist Double
HalfNormalDist Double
sigma) Maybe Double
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

cauchy :: forall env es x. Observable env x Double =>
     Double
  -> Double
  -> ObsVar x
  -> Model env es Double
cauchy :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Double =>
Double -> Double -> ObsVar x -> Model env es Double
cauchy Double
mu Double
sigma ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Double
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
CauchyDist Double
mu Double
sigma) Maybe Double
maybe_y Maybe String
tag)

cauchy' ::
  -- | location
     Double
  -- | scale
  -> Double
  -> Model env es Double
cauchy' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Double -> Model env es Double
cauchy' Double
mu Double
sigma = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
CauchyDist Double
mu Double
sigma) Maybe Double
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

halfCauchy :: forall env es x. Observable env x Double =>
     Double
  -> ObsVar x
  -> Model env es Double
halfCauchy :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Double =>
Double -> ObsVar x -> Model env es Double
halfCauchy Double
sigma ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Double
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> PrimDist Double
HalfCauchyDist Double
sigma) Maybe Double
maybe_y Maybe String
tag)

halfCauchy' ::
  -- | scale
     Double
  -> Model env es Double
halfCauchy' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Model env es Double
halfCauchy' Double
sigma = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> PrimDist Double
HalfCauchyDist Double
sigma) Maybe Double
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

bernoulli :: forall env es x. Observable env x Bool =>
     Double
  -> ObsVar x
  -> Model env es Bool
bernoulli :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Bool =>
Double -> ObsVar x -> Model env es Bool
bernoulli Double
p ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Bool)
-> Model env es Bool
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Bool)
 -> Model env es Bool)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Bool)
-> Model env es Bool
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Bool
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Bool -> Prog es Bool
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Bool -> Maybe Bool -> Maybe String -> Dist Bool
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> PrimDist Bool
BernoulliDist Double
p) Maybe Bool
maybe_y Maybe String
tag)

bernoulli' ::
  -- | probability of @True@
     Double
  -> Model env es Bool
bernoulli' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Model env es Bool
bernoulli' Double
p = ((Member Dist es, Member (ObsReader env) es) => Prog es Bool)
-> Model env es Bool
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Bool)
 -> Model env es Bool)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Bool)
-> Model env es Bool
forall a b. (a -> b) -> a -> b
$ do
  Dist Bool -> Prog es Bool
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Bool -> Maybe Bool -> Maybe String -> Dist Bool
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> PrimDist Bool
BernoulliDist Double
p) Maybe Bool
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

beta :: forall env es x. Observable env x Double =>
     Double
  -> Double
  -> ObsVar x
  -> Model env es Double
beta :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Double =>
Double -> Double -> ObsVar x -> Model env es Double
beta Double
α Double
β ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Double
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
BetaDist Double
α Double
β) Maybe Double
maybe_y Maybe String
tag)

beta' ::
  -- | shape 1 (α)
     Double
  -- | shape 2 (β)
  -> Double
  -> Model env es Double
beta' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Double -> Model env es Double
beta' Double
α Double
β = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
BetaDist Double
α Double
β) Maybe Double
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

binomial :: forall env es x. Observable env x Int =>
     Int
  -> Double
  -> ObsVar x
  -> Model env es Int
binomial :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Int =>
Int -> Double -> ObsVar x -> Model env es Int
binomial Int
n Double
p ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Int)
 -> Model env es Int)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Int
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Int -> Prog es Int
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Int -> Maybe Int -> Maybe String -> Dist Int
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Int -> Double -> PrimDist Int
BinomialDist Int
n Double
p) Maybe Int
maybe_y Maybe String
tag)

binomial' ::
  -- | number of trials
     Int
  -- | probability of successful trial
  -> Double
  -- | number of successful trials
  -> Model env es Int
binomial' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Int -> Double -> Model env es Int
binomial' Int
n Double
p = ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Int)
 -> Model env es Int)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall a b. (a -> b) -> a -> b
$ do
  Dist Int -> Prog es Int
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Int -> Maybe Int -> Maybe String -> Dist Int
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Int -> Double -> PrimDist Int
BinomialDist Int
n Double
p) Maybe Int
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

gamma :: forall env es x. Observable env x Double =>
     Double
  -> Double
  -> ObsVar x
  -> Model env es Double
gamma :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Double =>
Double -> Double -> ObsVar x -> Model env es Double
gamma Double
k Double
θ ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Double
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
GammaDist Double
k Double
θ) Maybe Double
maybe_y Maybe String
tag)

gamma' ::
  -- | shape (k)
     Double
  -- | scale (θ)
  -> Double
  -> Model env es Double
gamma' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Double -> Model env es Double
gamma' Double
k Double
θ = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
GammaDist Double
k Double
θ) Maybe Double
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

uniform :: forall env es x. Observable env x Double =>
     Double
  -> Double
  -> ObsVar x
  -> Model env es Double
uniform :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Double =>
Double -> Double -> ObsVar x -> Model env es Double
uniform Double
min Double
max ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Double
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
UniformDist Double
min Double
max) Maybe Double
maybe_y Maybe String
tag)

uniform' ::
  -- | lower-bound
     Double
  -- | upper-bound
  -> Double
  -> Model env es Double
uniform' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Double -> Model env es Double
uniform' Double
min Double
max = ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Double)
 -> Model env es Double)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Double)
-> Model env es Double
forall a b. (a -> b) -> a -> b
$ do
  Dist Double -> Prog es Double
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Double -> Maybe Double -> Maybe String -> Dist Double
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> Double -> PrimDist Double
UniformDist Double
min Double
max) Maybe Double
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)

poisson :: forall env es x. Observable env x Int =>
     Double
  -> ObsVar x
  -> Model env es Int
poisson :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol).
Observable env x Int =>
Double -> ObsVar x -> Model env es Int
poisson Double
λ ObsVar x
field = ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Int)
 -> Model env es Int)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall a b. (a -> b) -> a -> b
$ do
  let tag :: Maybe String
tag = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ObsVar x -> String
forall (x :: Symbol). ObsVar x -> String
varToStr ObsVar x
field
  Maybe Int
maybe_y <- forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) (x :: Symbol)
       a.
(Member (ObsReader env) es, Observable env x a) =>
ObsVar x -> Prog es (Maybe a)
ask @env ObsVar x
field
  Dist Int -> Prog es Int
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Int -> Maybe Int -> Maybe String -> Dist Int
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> PrimDist Int
PoissonDist Double
λ) Maybe Int
maybe_y Maybe String
tag)

poisson' ::
  -- | rate (λ)
     Double
  -- | number of events
  -> Model env es Int
poisson' :: forall (env :: [Assign Symbol (*)]) (es :: [* -> *]).
Double -> Model env es Int
poisson' Double
λ = ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall (env :: [Assign Symbol (*)]) (es :: [* -> *]) a.
((Member Dist es, Member (ObsReader env) es) => Prog es a)
-> Model env es a
Model (((Member Dist es, Member (ObsReader env) es) => Prog es Int)
 -> Model env es Int)
-> ((Member Dist es, Member (ObsReader env) es) => Prog es Int)
-> Model env es Int
forall a b. (a -> b) -> a -> b
$ do
  Dist Int -> Prog es Int
forall (e :: * -> *) (es :: [* -> *]) x.
Member e es =>
e x -> Prog es x
call (PrimDist Int -> Maybe Int -> Maybe String -> Dist Int
forall a. PrimDist a -> Maybe a -> Maybe String -> Dist a
Dist (Double -> PrimDist Int
PoissonDist Double
λ) Maybe Int
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing)