Language.Hakaru.Syntax.Prelude

A replacement for Haskell's Prelude, using the familiar symbols in order to construct ASTs and ABTs. This is only necessary if we want to use Hakaru as an embedded language in Haskell, but it also provides some examples of how to use the infrastructure.

TODO: is there a way to get rid of the need to specify '[] everywhere in here? Some sort of distinction between the Var vs the Open parts of View?

Basic syntax

Types and coercions

ann_ :: ABT Term abt => Sing a -> abt '[] a -> abt '[] a

triv :: TrivialABT Term '[] a -> TrivialABT Term '[] a

memo :: MemoizedABT Term '[] a -> MemoizedABT Term '[] a

coerceTo_ :: ABT Term abt => Coercion a b -> abt '[] a -> abt '[] b

fromProb :: ABT Term abt => abt '[] HProb -> abt '[] HReal

nat2int :: ABT Term abt => abt '[] HNat -> abt '[] HInt

nat2prob :: ABT Term abt => abt '[] HNat -> abt '[] HProb

fromInt :: ABT Term abt => abt '[] HInt -> abt '[] HReal

nat2real :: ABT Term abt => abt '[] HNat -> abt '[] HReal

unsafeFrom_ :: ABT Term abt => Coercion a b -> abt '[] b -> abt '[] a

unsafeProb :: ABT Term abt => abt '[] HReal -> abt '[] HProb

unsafeProbFraction :: forall abt a. (ABT Term abt, HFractional_ a) => abt '[] a -> abt '[] HProb

unsafeProbFraction_ :: ABT Term abt => HFractional a -> abt '[] a -> abt '[] HProb

unsafeProbSemiring :: forall abt a. (ABT Term abt, HSemiring_ a) => abt '[] a -> abt '[] HProb

unsafeProbSemiring_ :: ABT Term abt => HSemiring a -> abt '[] a -> abt '[] HProb

Numeric literals

literal_ :: ABT Term abt => Literal a -> abt '[] a

nat_ :: ABT Term abt => Natural -> abt '[] HNat

int_ :: ABT Term abt => Integer -> abt '[] HInt

prob_ :: ABT Term abt => NonNegativeRational -> abt '[] HProb

real_ :: ABT Term abt => Rational -> abt '[] HReal

fromRational :: forall abt a. (ABT Term abt, HFractional_ a) => Rational -> abt '[] a

half :: forall abt a. (ABT Term abt, HFractional_ a) => abt '[] a

third :: (ABT Term abt, HFractional_ a) => abt '[] a

Booleans

true :: ABT Term abt => abt '[] HBool

false :: ABT Term abt => abt '[] HBool

bool_ :: ABT Term abt => Bool -> abt '[] HBool

if_ :: ABT Term abt => abt '[] HBool -> abt '[] a -> abt '[] a -> abt '[] a

not :: ABT Term abt => abt '[] HBool -> abt '[] HBool

(&&) :: ABT Term abt => abt '[] HBool -> abt '[] HBool -> abt '[] HBool infixr 3

and :: ABT Term abt => [abt '[] HBool] -> abt '[] HBool

(||) :: ABT Term abt => abt '[] HBool -> abt '[] HBool -> abt '[] HBool infixr 2

or :: ABT Term abt => [abt '[] HBool] -> abt '[] HBool

nand :: ABT Term abt => abt '[] HBool -> abt '[] HBool -> abt '[] HBool

nor :: ABT Term abt => abt '[] HBool -> abt '[] HBool -> abt '[] HBool

Equality and ordering

(==) :: (ABT Term abt, HEq_ a) => abt '[] a -> abt '[] a -> abt '[] HBool infix 4

(/=) :: (ABT Term abt, HEq_ a) => abt '[] a -> abt '[] a -> abt '[] HBool infix 4

(<) :: (ABT Term abt, HOrd_ a) => abt '[] a -> abt '[] a -> abt '[] HBool infix 4

(<=) :: (ABT Term abt, HOrd_ a) => abt '[] a -> abt '[] a -> abt '[] HBool infix 4

(>) :: (ABT Term abt, HOrd_ a) => abt '[] a -> abt '[] a -> abt '[] HBool infix 4

(>=) :: (ABT Term abt, HOrd_ a) => abt '[] a -> abt '[] a -> abt '[] HBool infix 4

min :: (ABT Term abt, HOrd_ a) => abt '[] a -> abt '[] a -> abt '[] a

minimum :: (ABT Term abt, HOrd_ a) => [abt '[] a] -> abt '[] a

max :: (ABT Term abt, HOrd_ a) => abt '[] a -> abt '[] a -> abt '[] a

maximum :: (ABT Term abt, HOrd_ a) => [abt '[] a] -> abt '[] a

Semirings

zero :: forall abt a. (ABT Term abt, HSemiring_ a) => abt '[] a

zero_ :: ABT Term abt => HSemiring a -> abt '[] a

one :: forall abt a. (ABT Term abt, HSemiring_ a) => abt '[] a

one_ :: ABT Term abt => HSemiring a -> abt '[] a

(+) :: (ABT Term abt, HSemiring_ a) => abt '[] a -> abt '[] a -> abt '[] a infixl 6

sum :: (ABT Term abt, HSemiring_ a) => [abt '[] a] -> abt '[] a

(*) :: (ABT Term abt, HSemiring_ a) => abt '[] a -> abt '[] a -> abt '[] a infixl 7

prod :: (ABT Term abt, HSemiring_ a) => [abt '[] a] -> abt '[] a

(^) :: (ABT Term abt, HSemiring_ a) => abt '[] a -> abt '[] HNat -> abt '[] a infixr 8

square :: (ABT Term abt, HRing_ a) => abt '[] a -> abt '[] (NonNegative a)

unsafeMinusNat :: ABT Term abt => abt '[] HNat -> abt '[] HNat -> abt '[] HNat

unsafeMinusProb :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] HProb

unsafeMinus :: (ABT Term abt, HSemiring_ a) => abt '[] a -> abt '[] a -> abt '[] a

For any semiring we can attempt subtraction by lifting to a ring, subtracting there, and then lowering back to the semiring. Of course, the lowering step may well fail.

unsafeMinus_ :: ABT Term abt => HSemiring a -> abt '[] a -> abt '[] a -> abt '[] a

A variant of unsafeMinus for explicitly passing the semiring instance.

unsafeDiv :: (ABT Term abt, HSemiring_ a) => abt '[] a -> abt '[] a -> abt '[] a

For any semiring we can attempt division by lifting to a semifield, dividing there, and then lowering back to the semiring. Of course, the lowering step may well fail.

unsafeDiv_ :: ABT Term abt => HSemiring a -> abt '[] a -> abt '[] a -> abt '[] a

A variant of unsafeDiv for explicitly passing the semiring instance.

Rings

(-) :: (ABT Term abt, HRing_ a) => abt '[] a -> abt '[] a -> abt '[] a infixl 6

negate :: (ABT Term abt, HRing_ a) => abt '[] a -> abt '[] a

negative :: (ABT Term abt, HRing_ a) => abt '[] (NonNegative a) -> abt '[] a

An occasionally helpful variant of negate.

abs :: (ABT Term abt, HRing_ a) => abt '[] a -> abt '[] a

abs_ :: (ABT Term abt, HRing_ a) => abt '[] a -> abt '[] (NonNegative a)

signum :: (ABT Term abt, HRing_ a) => abt '[] a -> abt '[] a

Fractional

(/) :: (ABT Term abt, HFractional_ a) => abt '[] a -> abt '[] a -> abt '[] a infixl 7

recip :: (ABT Term abt, HFractional_ a) => abt '[] a -> abt '[] a

(^^) :: (ABT Term abt, HFractional_ a) => abt '[] a -> abt '[] HInt -> abt '[] a infixr 8

Radical

sqrt :: (ABT Term abt, HRadical_ a) => abt '[] a -> abt '[] a

thRootOf :: (ABT Term abt, HRadical_ a) => abt '[] HNat -> abt '[] a -> abt '[] a infixl 9

Integration

integrate :: ABT Term abt => abt '[] HReal -> abt '[] HReal -> (abt '[] HReal -> abt '[] HProb) -> abt '[] HProb

summate :: (ABT Term abt, HDiscrete_ a, HSemiring_ b, SingI a) => abt '[] a -> abt '[] a -> (abt '[] a -> abt '[] b) -> abt '[] b

product :: (ABT Term abt, HDiscrete_ a, HSemiring_ b, SingI a) => abt '[] a -> abt '[] a -> (abt '[] a -> abt '[] b) -> abt '[] b

Continuous

class RealProb a where

Minimal complete definition

(**), exp, erf, pi, gammaFunc

Methods

(**) :: ABT Term abt => abt '[] HProb -> abt '[] a -> abt '[] HProb infixr 8

exp :: ABT Term abt => abt '[] a -> abt '[] HProb

erf :: ABT Term abt => abt '[] a -> abt '[] a

pi :: ABT Term abt => abt '[] a

gammaFunc :: ABT Term abt => abt '[] a -> abt '[] HProb

Instances

RealProb HProb

Methods

(**) :: ABT Hakaru Term abt => abt [Hakaru] HProb -> abt [Hakaru] HProb -> abt [Hakaru] HProb

exp :: ABT Hakaru Term abt => abt [Hakaru] HProb -> abt [Hakaru] HProb

erf :: ABT Hakaru Term abt => abt [Hakaru] HProb -> abt [Hakaru] HProb

pi :: ABT Hakaru Term abt => abt [Hakaru] HProb

gammaFunc :: ABT Hakaru Term abt => abt [Hakaru] HProb -> abt [Hakaru] HProb

RealProb HReal

Methods

(**) :: ABT Hakaru Term abt => abt [Hakaru] HProb -> abt [Hakaru] HReal -> abt [Hakaru] HProb

exp :: ABT Hakaru Term abt => abt [Hakaru] HReal -> abt [Hakaru] HProb

erf :: ABT Hakaru Term abt => abt [Hakaru] HReal -> abt [Hakaru] HReal

pi :: ABT Hakaru Term abt => abt [Hakaru] HReal

gammaFunc :: ABT Hakaru Term abt => abt [Hakaru] HReal -> abt [Hakaru] HProb

class Integrable a where

Minimal complete definition

infinity

Methods

infinity :: ABT Term abt => abt '[] a

Instances

Integrable HNat

Methods

infinity :: ABT Hakaru Term abt => abt [Hakaru] HNat

Integrable HInt

Methods

infinity :: ABT Hakaru Term abt => abt [Hakaru] HInt

Integrable HProb

Methods

infinity :: ABT Hakaru Term abt => abt [Hakaru] HProb

Integrable HReal

Methods

infinity :: ABT Hakaru Term abt => abt [Hakaru] HReal

betaFunc :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] HProb

log :: ABT Term abt => abt '[] HProb -> abt '[] HReal

logBase :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] HReal

negativeInfinity :: (ABT Term abt, HRing_ a, Integrable a) => abt '[] a

Trig

sin :: ABT Term abt => abt '[] HReal -> abt '[] HReal

cos :: ABT Term abt => abt '[] HReal -> abt '[] HReal

tan :: ABT Term abt => abt '[] HReal -> abt '[] HReal

asin :: ABT Term abt => abt '[] HReal -> abt '[] HReal

acos :: ABT Term abt => abt '[] HReal -> abt '[] HReal

atan :: ABT Term abt => abt '[] HReal -> abt '[] HReal

sinh :: ABT Term abt => abt '[] HReal -> abt '[] HReal

cosh :: ABT Term abt => abt '[] HReal -> abt '[] HReal

tanh :: ABT Term abt => abt '[] HReal -> abt '[] HReal

asinh :: ABT Term abt => abt '[] HReal -> abt '[] HReal

acosh :: ABT Term abt => abt '[] HReal -> abt '[] HReal

atanh :: ABT Term abt => abt '[] HReal -> abt '[] HReal

Measures

Abstract nonsense

dirac :: ABT Term abt => abt '[] a -> abt '[] (HMeasure a)

(<$>) :: (ABT Term abt, SingI a) => (abt '[] a -> abt '[] b) -> abt '[] (HMeasure a) -> abt '[] (HMeasure b) infixl 4

(<*>) :: (ABT Term abt, SingI a, SingI b) => abt '[] (HMeasure (a :-> b)) -> abt '[] (HMeasure a) -> abt '[] (HMeasure b) infixl 4

N.B, this function may introduce administrative redexes. Moreover, it's not clear that we should even allow the type 'HMeasure (a ':-> b)!

(<*) :: (ABT Term abt, SingI a, SingI b) => abt '[] (HMeasure a) -> abt '[] (HMeasure b) -> abt '[] (HMeasure a) infixl 4

(*>) :: (ABT Term abt, SingI a) => abt '[] (HMeasure a) -> abt '[] (HMeasure b) -> abt '[] (HMeasure b) infixl 4

(>>=) :: ABT Term abt => abt '[] (HMeasure a) -> (abt '[] a -> abt '[] (HMeasure b)) -> abt '[] (HMeasure b) infixl 1

(>>) :: (ABT Term abt, SingI a) => abt '[] (HMeasure a) -> abt '[] (HMeasure b) -> abt '[] (HMeasure b) infixl 1

bindx :: (ABT Term abt, SingI a, SingI b) => abt '[] (HMeasure a) -> (abt '[] a -> abt '[] (HMeasure b)) -> abt '[] (HMeasure (HPair a b))

liftM2 :: (ABT Term abt, SingI a, SingI b) => (abt '[] a -> abt '[] b -> abt '[] c) -> abt '[] (HMeasure a) -> abt '[] (HMeasure b) -> abt '[] (HMeasure c)

Linear operators

superpose :: ABT Term abt => NonEmpty (abt '[] HProb, abt '[] (HMeasure a)) -> abt '[] (HMeasure a)

(<|>) :: ABT Term abt => abt '[] (HMeasure a) -> abt '[] (HMeasure a) -> abt '[] (HMeasure a)

The sum of two measures. Is called mplus in the Core Hakaru paper.

weight :: ABT Term abt => abt '[] HProb -> abt '[] (HMeasure HUnit)

Adjust the weight of the current measure.

N.B., the name for this function is terribly inconsistent across the literature, even just the Hakaru literature, let alone the Hakaru code base. It is variously called "factor" or "weight"; though "factor" is also used to mean the function factor or the function observe, and "weight" is also used to mean the weight function.

withWeight :: ABT Term abt => abt '[] HProb -> abt '[] (HMeasure w) -> abt '[] (HMeasure w)

A variant of weight which removes an administrative (dirac unit >>) redex.

TODO: ideally we'll be able to get rid of this function entirely, and be able to trust optimization to clean up any redexes introduced by weight.

weightedDirac :: (ABT Term abt, SingI a) => abt '[] a -> abt '[] HProb -> abt '[] (HMeasure a)

A particularly common use case of weight:

weightedDirac e p
    == weight p (dirac e)
    == weight p *> dirac e
    == dirac e <* weight p

reject :: ABT Term abt => Sing (HMeasure a) -> abt '[] (HMeasure a)

The empty measure. Is called fail in the Core Hakaru paper.

guard :: ABT Term abt => abt '[] HBool -> abt '[] (HMeasure HUnit)

Assert that a condition is true.

N.B., the name for this function is terribly inconsistent across the literature, even just the Hakaru literature, let alone the Hakaru code base. It is variously called "factor" or "observe"; though "factor" is also used to mean the function pose, and "observe" is also used to mean the backwards part of Lazy.hs.

withGuard :: ABT Term abt => abt '[] HBool -> abt '[] (HMeasure a) -> abt '[] (HMeasure a)

A variant of guard which removes an administrative (dirac unit >>) redex.

TODO: ideally we'll be able to get rid of this function entirely, and be able to trust optimization to clean up any redexes introduced by guard.

Measure operators

When two versions of the same operator are given, the one without the prime builds an AST using the built-in operator, whereas the one with the prime is a default definition in terms of more primitive measure operators.

lebesgue :: ABT Term abt => abt '[] (HMeasure HReal)

counting :: ABT Term abt => abt '[] (HMeasure HInt)

densityCategorical :: ABT Term abt => abt '[] (HArray HProb) -> abt '[] HNat -> abt '[] HProb

categorical :: ABT Term abt => abt '[] (HArray HProb) -> abt '[] (HMeasure HNat)

categorical' :: ABT Term abt => abt '[] (HArray HProb) -> abt '[] (HMeasure HNat)

densityUniform :: ABT Term abt => abt '[] HReal -> abt '[] HReal -> abt '[] HReal -> abt '[] HProb

uniform :: ABT Term abt => abt '[] HReal -> abt '[] HReal -> abt '[] (HMeasure HReal)

uniform' :: ABT Term abt => abt '[] HReal -> abt '[] HReal -> abt '[] (HMeasure HReal)

densityNormal :: ABT Term abt => abt '[] HReal -> abt '[] HProb -> abt '[] HReal -> abt '[] HProb

normal :: ABT Term abt => abt '[] HReal -> abt '[] HProb -> abt '[] (HMeasure HReal)

normal' :: ABT Term abt => abt '[] HReal -> abt '[] HProb -> abt '[] (HMeasure HReal)

densityPoisson :: ABT Term abt => abt '[] HProb -> abt '[] HNat -> abt '[] HProb

poisson :: ABT Term abt => abt '[] HProb -> abt '[] (HMeasure HNat)

poisson' :: ABT Term abt => abt '[] HProb -> abt '[] (HMeasure HNat)

densityGamma :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] HProb -> abt '[] HProb

gamma :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] (HMeasure HProb)

gamma' :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] (HMeasure HProb)

densityBeta :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] HProb -> abt '[] HProb

beta :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] (HMeasure HProb)

beta' :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] (HMeasure HProb)

beta'' :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] (HMeasure HProb)

plateWithVar :: ABT Term abt => abt '[] HNat -> Variable HNat -> abt '[] (HMeasure a) -> abt '[] (HMeasure (HArray a))

plate :: ABT Term abt => abt '[] HNat -> (abt '[] HNat -> abt '[] (HMeasure a)) -> abt '[] (HMeasure (HArray a))

plate' :: (ABT Term abt, SingI a) => abt '[] (HArray (HMeasure a)) -> abt '[] (HMeasure (HArray a))

chain :: (ABT Term abt, SingI s) => abt '[] HNat -> abt '[] s -> (abt '[] s -> abt '[] (HMeasure (HPair a s))) -> abt '[] (HMeasure (HPair (HArray a) s))

chain' :: (ABT Term abt, SingI s, SingI a) => abt '[] (HArray (s :-> HMeasure (HPair a s))) -> abt '[] s -> abt '[] (HMeasure (HPair (HArray a) s))

invgamma :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] (HMeasure HProb)

exponential :: ABT Term abt => abt '[] HProb -> abt '[] (HMeasure HProb)

chi2 :: ABT Term abt => abt '[] HProb -> abt '[] (HMeasure HProb)

cauchy :: ABT Term abt => abt '[] HReal -> abt '[] HProb -> abt '[] (HMeasure HReal)

laplace :: ABT Term abt => abt '[] HReal -> abt '[] HProb -> abt '[] (HMeasure HReal)

studentT :: ABT Term abt => abt '[] HReal -> abt '[] HProb -> abt '[] HProb -> abt '[] (HMeasure HReal)

weibull :: ABT Term abt => abt '[] HProb -> abt '[] HProb -> abt '[] (HMeasure HProb)

bern :: ABT Term abt => abt '[] HProb -> abt '[] (HMeasure HBool)

mix :: ABT Term abt => abt '[] (HArray HProb) -> abt '[] (HMeasure HNat)

binomial :: ABT Term abt => abt '[] HNat -> abt '[] HProb -> abt '[] (HMeasure HInt)

negativeBinomial :: ABT Term abt => abt '[] HNat -> abt '[] HProb -> abt '[] (HMeasure HNat)

geometric :: ABT Term abt => abt '[] HProb -> abt '[] (HMeasure HNat)

multinomial :: ABT Term abt => abt '[] HNat -> abt '[] (HArray HProb) -> abt '[] (HMeasure (HArray HProb))

dirichlet :: ABT Term abt => abt '[] (HArray HProb) -> abt '[] (HMeasure (HArray HProb))

Data types (other than booleans)

datum_ :: ABT Term abt => Datum (abt '[]) (HData' t) -> abt '[] (HData' t)

Case and Branch

case_ :: ABT Term abt => abt '[] a -> [Branch a abt b] -> abt '[] b

branch :: ABT Term abt => Pattern xs a -> abt xs b -> Branch a abt b

HUnit

unit :: ABT Term abt => abt '[] HUnit

HPair

pair :: (ABT Term abt, SingI a, SingI b) => abt '[] a -> abt '[] b -> abt '[] (HPair a b)

pair_ :: ABT Term abt => Sing a -> Sing b -> abt '[] a -> abt '[] b -> abt '[] (HPair a b)

unpair :: forall abt a b c. ABT Term abt => abt '[] (HPair a b) -> (abt '[] a -> abt '[] b -> abt '[] c) -> abt '[] c

fst :: ABT Term abt => abt '[] (HPair a b) -> abt '[] a

snd :: ABT Term abt => abt '[] (HPair a b) -> abt '[] b

swap :: (ABT Term abt, SingI a, SingI b) => abt '[] (HPair a b) -> abt '[] (HPair b a)

HEither

left :: (ABT Term abt, SingI a, SingI b) => abt '[] a -> abt '[] (HEither a b)

right :: (ABT Term abt, SingI a, SingI b) => abt '[] b -> abt '[] (HEither a b)

uneither :: ABT Term abt => abt '[] (HEither a b) -> (abt '[] a -> abt '[] c) -> (abt '[] b -> abt '[] c) -> abt '[] c

HMaybe

nothing :: (ABT Term abt, SingI a) => abt '[] (HMaybe a)

just :: (ABT Term abt, SingI a) => abt '[] a -> abt '[] (HMaybe a)

maybe :: (ABT Term abt, SingI a) => Maybe (abt '[] a) -> abt '[] (HMaybe a)

unmaybe :: ABT Term abt => abt '[] (HMaybe a) -> abt '[] b -> (abt '[] a -> abt '[] b) -> abt '[] b

HList

nil :: (ABT Term abt, SingI a) => abt '[] (HList a)

cons :: (ABT Term abt, SingI a) => abt '[] a -> abt '[] (HList a) -> abt '[] (HList a)

list :: (ABT Term abt, SingI a) => [abt '[] a] -> abt '[] (HList a)

Lambda calculus

lam :: (ABT Term abt, SingI a) => (abt '[] a -> abt '[] b) -> abt '[] (a :-> b)

A variant of lamWithVar for automatically computing the type via sing.

lamWithVar :: ABT Term abt => Text -> Sing a -> (abt '[] a -> abt '[] b) -> abt '[] (a :-> b)

Create a lambda abstraction. The first two arguments give the hint and type of the lambda-bound variable in the result. If you want to automatically fill those in, then see lam.

let_ :: ABT Term abt => abt '[] a -> (abt '[] a -> abt '[] b) -> abt '[] b

app :: ABT Term abt => abt '[] (a :-> b) -> abt '[] a -> abt '[] b infixl 9

app2 :: ABT Term abt => abt '[] (a :-> (b :-> c)) -> abt '[] a -> abt '[] b -> abt '[] c

app3 :: ABT Term abt => abt '[] (a :-> (b :-> (c :-> d))) -> abt '[] a -> abt '[] b -> abt '[] c -> abt '[] d

Arrays

empty :: (ABT Term abt, SingI a) => abt '[] (HArray a)

arrayWithVar :: ABT Term abt => abt '[] HNat -> Variable HNat -> abt '[] a -> abt '[] (HArray a)

array :: ABT Term abt => abt '[] HNat -> (abt '[] HNat -> abt '[] a) -> abt '[] (HArray a)

(!) :: ABT Term abt => abt '[] (HArray a) -> abt '[] HNat -> abt '[] a infixl 9

size :: ABT Term abt => abt '[] (HArray a) -> abt '[] HNat

reduce :: ABT Term abt => (abt '[] a -> abt '[] a -> abt '[] a) -> abt '[] a -> abt '[] (HArray a) -> abt '[] a

sumV :: (ABT Term abt, HSemiring_ a) => abt '[] (HArray a) -> abt '[] a

summateV :: ABT Term abt => abt '[] (HArray HProb) -> abt '[] HProb

appendV :: ABT Term abt => abt '[] (HArray a) -> abt '[] (HArray a) -> abt '[] (HArray a)

mapV :: ABT Term abt => (abt '[] a -> abt '[] b) -> abt '[] (HArray a) -> abt '[] (HArray b)

mapWithIndex :: ABT Term abt => (abt '[] HNat -> abt '[] a -> abt '[] b) -> abt '[] (HArray a) -> abt '[] (HArray b)

normalizeV :: ABT Term abt => abt '[] (HArray HProb) -> abt '[] (HArray HProb)

constV :: ABT Term abt => abt '[] HNat -> abt '[] b -> abt '[] (HArray b)

unitV :: ABT Term abt => abt '[] HNat -> abt '[] HNat -> abt '[] (HArray HProb)

zipWithV :: ABT Term abt => (abt '[] a -> abt '[] b -> abt '[] c) -> abt '[] (HArray a) -> abt '[] (HArray b) -> abt '[] (HArray c)

Implementation details

primOp0_ :: ABT Term abt => PrimOp '[] a -> abt '[] a

primOp1_ :: ABT Term abt => PrimOp '[a] b -> abt '[] a -> abt '[] b

primOp2_ :: ABT Term abt => PrimOp '[a, b] c -> abt '[] a -> abt '[] b -> abt '[] c

primOp3_ :: ABT Term abt => PrimOp '[a, b, c] d -> abt '[] a -> abt '[] b -> abt '[] c -> abt '[] d

arrayOp0_ :: ABT Term abt => ArrayOp '[] a -> abt '[] a

arrayOp1_ :: ABT Term abt => ArrayOp '[a] b -> abt '[] a -> abt '[] b

arrayOp2_ :: ABT Term abt => ArrayOp '[a, b] c -> abt '[] a -> abt '[] b -> abt '[] c

arrayOp3_ :: ABT Term abt => ArrayOp '[a, b, c] d -> abt '[] a -> abt '[] b -> abt '[] c -> abt '[] d

measure0_ :: ABT Term abt => MeasureOp '[] a -> abt '[] (HMeasure a)

measure1_ :: ABT Term abt => MeasureOp '[a] b -> abt '[] a -> abt '[] (HMeasure b)

measure2_ :: ABT Term abt => MeasureOp '[a, b] c -> abt '[] a -> abt '[] b -> abt '[] (HMeasure c)

unsafeNaryOp_ :: ABT Term abt => NaryOp a -> [abt '[] a] -> abt '[] a

Apply an n-ary operator to a list. This smart constructor will flatten nested calls to the same operator. And if there is exactly one element in the flattened sequence, then it will remove the NaryOp_ node from the AST.

N.B., if the flattened sequence is empty, this smart constructor will return an AST which applies the operator to the empty sequence; which may or may not be unsafe. If the operator has an identity element, then it's fine (operating on the empty sequence evaluates to the identity element). However, if the operator doesn't have an identity, then the generated code will error whenever we attempt to run it.

naryOp_withIdentity :: ABT Term abt => NaryOp a -> abt '[] a -> [abt '[] a] -> abt '[] a

A variant of unsafeNaryOp_ which will replace operating over the empty sequence with a specified identity element. The produced AST has the same semantics, we're just preemptively evaluating/simplifying the NaryOp_ node of the AST.

N.B., this function does not simplify away the identity element if it exists in the flattened sequence! We should add that in the future.

naryOp2_ :: ABT Term abt => NaryOp a -> abt '[] a -> abt '[] a -> abt '[] a