Dino.Interpretation

Interpretation of tagless expressions

Type checking

Monadic interpretation

eval :: Exp Identity a -> a

Pure evaluation

evalF :: Exp f a -> f a

Functorial evaluation

Can, for example, have the type

evalF :: Exp Maybe a -> Maybe a

Folding

newtype Fold e a

A folding interpretation

Instances of expression classes work by monoidal folding over e (see foldMonoid).

Constructors

Fold

Fields

• fold :: e

Instances

Functor (Fold e)

Defined in Dino.Interpretation

Methods

fmap :: (a -> b) -> Fold e a -> Fold e b

(<$) :: a -> Fold e b -> Fold e a

Monoid e => Applicative (Fold e)

Defined in Dino.Interpretation

Methods

pure :: a -> Fold e a

(<*>) :: Fold e (a -> b) -> Fold e a -> Fold e b

liftA2 :: (a -> b -> c) -> Fold e a -> Fold e b -> Fold e c

(*>) :: Fold e a -> Fold e b -> Fold e b

(<*) :: Fold e a -> Fold e b -> Fold e a

AssertExp (Fold e)

Ignoring assertion

Defined in Dino.Interpretation

Methods

assert :: Text -> Fold e Bool -> Fold e a -> Fold e a

assertEq :: (Eq a, Show a) => Text -> Fold e a -> Fold e a -> Fold e a

Monoid e => FieldExp (Fold e)

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> Fold e r -> Fold e a

Monoid e => LetExp (Fold e)

Defined in Dino.Interpretation

Methods

letE :: DinoType a => Text -> Fold e a -> (Fold e a -> Fold e b) -> Fold e b

Monoid e => TupleExp (Fold e)

Defined in Dino.Interpretation

Methods

pair :: Fold e a -> Fold e b -> Fold e (a, b)

fstE :: Fold e (a, b) -> Fold e a

sndE :: Fold e (a, b) -> Fold e b

Monoid e => ListExp (Fold e)

Defined in Dino.Interpretation

Methods

mapE :: DinoType a => (Fold e a -> Fold e b) -> Fold e [a] -> Fold e [b]

dropWhileE :: DinoType a => (Fold e a -> Fold e Bool) -> Fold e [a] -> Fold e [a]

foldE :: (DinoType a, DinoType b) => (Fold e a -> Fold e b -> Fold e a) -> Fold e a -> Fold e [b] -> Fold e a

Monoid e => ListExpFO (Fold e)

Defined in Dino.Interpretation

Methods

range :: Enum a => Fold e a -> Fold e a -> Fold e [a]

list :: DinoType a => [Fold e a] -> Fold e [a]

headE :: Fold e [a] -> Fold e (Maybe a)

append :: Fold e [a] -> Fold e [a] -> Fold e [a]

Monoid e => CondExp (Fold e)

Interprets all branches

Defined in Dino.Interpretation

Methods

maybe :: DinoType a => Fold e b -> (Fold e a -> Fold e b) -> Fold e (Maybe a) -> Fold e b

Monoid e => CondExpFO (Fold e)

Interprets all branches

Defined in Dino.Interpretation

Methods

just :: Fold e a -> Fold e (Maybe a)

cases :: [Fold e Bool :-> Fold e a] -> (Otherwise :-> Fold e a) -> Fold e a

partial_cases :: HasCallStack => [Fold e Bool :-> Fold e a] -> Fold e a

Monoid e => CompareExp (Fold e)

Defined in Dino.Interpretation

Methods

eq :: Eq a => Fold e a -> Fold e a -> Fold e Bool

neq :: Eq a => Fold e a -> Fold e a -> Fold e Bool

lt :: Ord a => Fold e a -> Fold e a -> Fold e Bool

gt :: Ord a => Fold e a -> Fold e a -> Fold e Bool

lte :: Ord a => Fold e a -> Fold e a -> Fold e Bool

gte :: Ord a => Fold e a -> Fold e a -> Fold e Bool

min :: Ord a => Fold e a -> Fold e a -> Fold e a

max :: Ord a => Fold e a -> Fold e a -> Fold e a

Monoid e => LogicExp (Fold e)

Defined in Dino.Interpretation

Methods

not :: Fold e Bool -> Fold e Bool

conj :: Fold e Bool -> Fold e Bool -> Fold e Bool

disj :: Fold e Bool -> Fold e Bool -> Fold e Bool

xor :: Fold e Bool -> Fold e Bool -> Fold e Bool

Monoid e => FracExp (Fold e)

Defined in Dino.Interpretation

Methods

fdiv :: (Fractional a, Eq a) => Fold e a -> Fold e a -> Fold e a

Monoid e => NumExp (Fold e)

Defined in Dino.Interpretation

Methods

add :: Num a => Fold e a -> Fold e a -> Fold e a

sub :: Num a => Fold e a -> Fold e a -> Fold e a

mul :: Num a => Fold e a -> Fold e a -> Fold e a

absE :: Num a => Fold e a -> Fold e a

signE :: Num a => Fold e a -> Fold e a

fromIntegral :: (Integral a, DinoType b, Num b) => Fold e a -> Fold e b

floor :: (RealFrac a, DinoType b, Integral b) => Fold e a -> Fold e b

truncate :: (RealFrac a, DinoType b, Integral b) => Fold e a -> Fold e b

roundN :: RealFrac a => Int -> Fold e a -> Fold e a

Monoid e => ConstExp (Fold e)

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> Fold e a

Semigroup e => LetIntensional (Fold e)

Defined in Dino.Interpretation

Methods

letI :: DinoType a => Text -> Fold e a -> Fold e b -> Fold e b

Semigroup e => ListIntensional (Fold e)

Defined in Dino.Interpretation

Methods

mapI :: DinoType a => Text -> Fold e b -> Fold e [a] -> Fold e [b]

dropWhileI :: DinoType a => Text -> Fold e Bool -> Fold e [a] -> Fold e [a]

foldI :: (DinoType a, DinoType b) => Text -> Text -> Fold e a -> Fold e a -> Fold e [b] -> Fold e a

Semigroup e => CondIntensional (Fold e)

Defined in Dino.Interpretation

Methods

maybeI :: DinoType a => Text -> Fold e b -> Fold e b -> Fold e (Maybe a) -> Fold e b

Monoid e => VarExp (Fold e)

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> Fold e a

AnnExp ann (Fold e :: Type -> Type)

Defined in Dino.Interpretation

Methods

ann :: ann -> Fold e a -> Fold e a

Eq e => Eq (Fold e a)

Defined in Dino.Interpretation

Methods

(==) :: Fold e a -> Fold e a -> Bool

(/=) :: Fold e a -> Fold e a -> Bool

Show e => Show (Fold e a)

Defined in Dino.Interpretation

Methods

showsPrec :: Int -> Fold e a -> ShowS

show :: Fold e a -> String

showList :: [Fold e a] -> ShowS

Semigroup e => Semigroup (Fold e a)

Defined in Dino.Interpretation

Methods

(<>) :: Fold e a -> Fold e a -> Fold e a

sconcat :: NonEmpty (Fold e a) -> Fold e a

stimes :: Integral b => b -> Fold e a -> Fold e a

Monoid e => Monoid (Fold e a)

Defined in Dino.Interpretation

Methods

mempty :: Fold e a

mappend :: Fold e a -> Fold e a -> Fold e a

mconcat :: [Fold e a] -> Fold e a

FoldN f e => FoldN (Fold e a -> f) e

Defined in Dino.Interpretation

Methods

foldN :: e -> (e -> e -> e) -> Fold e a -> f

FoldN (Fold e a) e

Defined in Dino.Interpretation

Methods

foldN :: e -> (e -> e -> e) -> Fold e a

class FoldN f e | f -> e where

N-ary folding functions

Methods

foldN :: e -> (e -> e -> e) -> f

foldN e (*) returns an n-ary function of the following form:

\(Fold a) (Fold b) ... (Fold x) -> Fold (e * a * b * ... x)

(here * denotes any binary operator, and it's assumed to be right- associative.)

Instances

FoldN f e => FoldN (Fold e a -> f) e

Defined in Dino.Interpretation

Methods

foldN :: e -> (e -> e -> e) -> Fold e a -> f

FoldN (Fold e a) e

Defined in Dino.Interpretation

Methods

foldN :: e -> (e -> e -> e) -> Fold e a

foldMonoid :: (FoldN f e, Monoid e) => f

@foldMonoid returns an n-ary function of the following form:

\(Fold a) (Fold b) ... (Fold x) -> Fold (mempty <> a <> b <> ... x)

where mempty and <> are the methods of the Monoid class.

Product of interpretations

data (e1 :×: e2) a

Product of two interpretations

The product is used to run two interpretations in parallel. Note that there are no instances for HOS classes. Instead, use Intensional (e1 :×: e2) in order to derive an interpretation of HOS classes for products.

Constructors

(:×:)

Fields

• prodFst :: e1 a
• prodSnd :: e2 a

Instances

(AnnExp ann e1, AnnExp ann e2) => AnnExp ann (e1 :×: e2 :: Type -> Type)

Defined in Dino.Interpretation

Methods

ann :: ann -> (e1 :×: e2) a -> (e1 :×: e2) a

(AssertExp e1, AssertExp e2) => AssertExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

assert :: Text -> (e1 :×: e2) Bool -> (e1 :×: e2) a -> (e1 :×: e2) a

assertEq :: (Eq a, Show a) => Text -> (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) a

(FieldExp e1, FieldExp e2) => FieldExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> (e1 :×: e2) r -> (e1 :×: e2) a

(TupleExp e1, TupleExp e2) => TupleExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

pair :: (e1 :×: e2) a -> (e1 :×: e2) b -> (e1 :×: e2) (a, b)

fstE :: (e1 :×: e2) (a, b) -> (e1 :×: e2) a

sndE :: (e1 :×: e2) (a, b) -> (e1 :×: e2) b

(ListExpFO e1, ListExpFO e2) => ListExpFO (e1 :×: e2)

Defined in Dino.Interpretation

Methods

range :: Enum a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) [a]

list :: DinoType a => [(e1 :×: e2) a] -> (e1 :×: e2) [a]

headE :: (e1 :×: e2) [a] -> (e1 :×: e2) (Maybe a)

append :: (e1 :×: e2) [a] -> (e1 :×: e2) [a] -> (e1 :×: e2) [a]

(CondExpFO e1, CondExpFO e2) => CondExpFO (e1 :×: e2)

Defined in Dino.Interpretation

Methods

just :: (e1 :×: e2) a -> (e1 :×: e2) (Maybe a)

cases :: [(e1 :×: e2) Bool :-> (e1 :×: e2) a] -> (Otherwise :-> (e1 :×: e2) a) -> (e1 :×: e2) a

partial_cases :: HasCallStack => [(e1 :×: e2) Bool :-> (e1 :×: e2) a] -> (e1 :×: e2) a

(CompareExp e1, CompareExp e2) => CompareExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

eq :: Eq a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) Bool

neq :: Eq a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) Bool

lt :: Ord a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) Bool

gt :: Ord a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) Bool

lte :: Ord a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) Bool

gte :: Ord a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) Bool

min :: Ord a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) a

max :: Ord a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) a

(LogicExp e1, LogicExp e2) => LogicExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

not :: (e1 :×: e2) Bool -> (e1 :×: e2) Bool

conj :: (e1 :×: e2) Bool -> (e1 :×: e2) Bool -> (e1 :×: e2) Bool

disj :: (e1 :×: e2) Bool -> (e1 :×: e2) Bool -> (e1 :×: e2) Bool

xor :: (e1 :×: e2) Bool -> (e1 :×: e2) Bool -> (e1 :×: e2) Bool

(FracExp e1, FracExp e2) => FracExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

fdiv :: (Fractional a, Eq a) => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) a

(NumExp e1, NumExp e2) => NumExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

add :: Num a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) a

sub :: Num a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) a

mul :: Num a => (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) a

absE :: Num a => (e1 :×: e2) a -> (e1 :×: e2) a

signE :: Num a => (e1 :×: e2) a -> (e1 :×: e2) a

fromIntegral :: (Integral a, DinoType b, Num b) => (e1 :×: e2) a -> (e1 :×: e2) b

floor :: (RealFrac a, DinoType b, Integral b) => (e1 :×: e2) a -> (e1 :×: e2) b

truncate :: (RealFrac a, DinoType b, Integral b) => (e1 :×: e2) a -> (e1 :×: e2) b

roundN :: RealFrac a => Int -> (e1 :×: e2) a -> (e1 :×: e2) a

(ConstExp e1, ConstExp e2) => ConstExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> (e1 :×: e2) a

(LetIntensional e1, LetIntensional e2) => LetIntensional (e1 :×: e2)

Defined in Dino.Interpretation

Methods

letI :: DinoType a => Text -> (e1 :×: e2) a -> (e1 :×: e2) b -> (e1 :×: e2) b

(ListIntensional e1, ListIntensional e2) => ListIntensional (e1 :×: e2)

Defined in Dino.Interpretation

Methods

mapI :: DinoType a => Text -> (e1 :×: e2) b -> (e1 :×: e2) [a] -> (e1 :×: e2) [b]

dropWhileI :: DinoType a => Text -> (e1 :×: e2) Bool -> (e1 :×: e2) [a] -> (e1 :×: e2) [a]

foldI :: (DinoType a, DinoType b) => Text -> Text -> (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) [b] -> (e1 :×: e2) a

(CondIntensional e1, CondIntensional e2) => CondIntensional (e1 :×: e2)

Defined in Dino.Interpretation

Methods

maybeI :: DinoType a => Text -> (e1 :×: e2) b -> (e1 :×: e2) b -> (e1 :×: e2) (Maybe a) -> (e1 :×: e2) b

(VarExp e1, VarExp e2) => VarExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> (e1 :×: e2) a

mkProd :: (lang e1, lang e2) => proxy lang -> (forall e. lang e => e a) -> (e1 :×: e2) a

liftProd :: (lang e1, lang e2) => proxy lang -> (forall e. lang e => e a -> e b) -> (e1 :×: e2) a -> (e1 :×: e2) b

liftProd2 :: (lang e1, lang e2) => proxy lang -> (forall e. lang e => e a -> e b -> e c) -> (e1 :×: e2) a -> (e1 :×: e2) b -> (e1 :×: e2) c

liftProd3 :: (lang e1, lang e2) => proxy lang -> (forall e. lang e => e a -> e b -> e c -> e d) -> (e1 :×: e2) a -> (e1 :×: e2) b -> (e1 :×: e2) c -> (e1 :×: e2) d

Intensional interpretation

type BindSet = HashMap Text Int

Representation of the set of variables used by bindings in an expression. An entry (v, n) means that the base name v is used possibly appended with a number that is at most n.

Since the keys represent variable base names, they are not allowed to end with digits.

freshVar :: Text -> BindSet -> (Text, BindSet)

Return an unused variable name from the given base name

The returned BindSet includes the new variable.

newtype Intensional e a

Allow intensional interpretation of higher-order constructs

Intensional is used to obtain instances of HOS classes from their intensional counterparts. For example, given (CondExpFO e, VarExp e, CondIntensional e), we get CondExp (Intensional e).

Pairing the interpretation with a BindSet allows generating symbolic variables to inspect higher-order constructs rather than just running them.

Constructors

Intensional

Fields

• unIntensional :: (Fold BindSet :×: e) a

Instances

AssertExp e => AssertExp (Intensional e)

Defined in Dino.Interpretation

Methods

assert :: Text -> Intensional e Bool -> Intensional e a -> Intensional e a

assertEq :: (Eq a, Show a) => Text -> Intensional e a -> Intensional e a -> Intensional e a

FieldExp e => FieldExp (Intensional e)

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> Intensional e r -> Intensional e a

(VarExp e, LetIntensional e) => LetExp (Intensional e)

Defined in Dino.Interpretation

Methods

letE :: DinoType a => Text -> Intensional e a -> (Intensional e a -> Intensional e b) -> Intensional e b

TupleExp e => TupleExp (Intensional e)

Defined in Dino.Interpretation

Methods

pair :: Intensional e a -> Intensional e b -> Intensional e (a, b)

fstE :: Intensional e (a, b) -> Intensional e a

sndE :: Intensional e (a, b) -> Intensional e b

(ListExpFO e, VarExp e, ListIntensional e) => ListExp (Intensional e)

Defined in Dino.Interpretation

Methods

mapE :: DinoType a => (Intensional e a -> Intensional e b) -> Intensional e [a] -> Intensional e [b]

dropWhileE :: DinoType a => (Intensional e a -> Intensional e Bool) -> Intensional e [a] -> Intensional e [a]

foldE :: (DinoType a, DinoType b) => (Intensional e a -> Intensional e b -> Intensional e a) -> Intensional e a -> Intensional e [b] -> Intensional e a

ListExpFO e => ListExpFO (Intensional e)

Defined in Dino.Interpretation

Methods

range :: Enum a => Intensional e a -> Intensional e a -> Intensional e [a]

list :: DinoType a => [Intensional e a] -> Intensional e [a]

headE :: Intensional e [a] -> Intensional e (Maybe a)

append :: Intensional e [a] -> Intensional e [a] -> Intensional e [a]

(CondExpFO e, VarExp e, CondIntensional e) => CondExp (Intensional e)

Defined in Dino.Interpretation

Methods

maybe :: DinoType a => Intensional e b -> (Intensional e a -> Intensional e b) -> Intensional e (Maybe a) -> Intensional e b

CondExpFO e => CondExpFO (Intensional e)

Defined in Dino.Interpretation

Methods

just :: Intensional e a -> Intensional e (Maybe a)

cases :: [Intensional e Bool :-> Intensional e a] -> (Otherwise :-> Intensional e a) -> Intensional e a

partial_cases :: HasCallStack => [Intensional e Bool :-> Intensional e a] -> Intensional e a

CompareExp e => CompareExp (Intensional e)

Defined in Dino.Interpretation

Methods

eq :: Eq a => Intensional e a -> Intensional e a -> Intensional e Bool

neq :: Eq a => Intensional e a -> Intensional e a -> Intensional e Bool

lt :: Ord a => Intensional e a -> Intensional e a -> Intensional e Bool

gt :: Ord a => Intensional e a -> Intensional e a -> Intensional e Bool

lte :: Ord a => Intensional e a -> Intensional e a -> Intensional e Bool

gte :: Ord a => Intensional e a -> Intensional e a -> Intensional e Bool

min :: Ord a => Intensional e a -> Intensional e a -> Intensional e a

max :: Ord a => Intensional e a -> Intensional e a -> Intensional e a

LogicExp e => LogicExp (Intensional e)

Defined in Dino.Interpretation

Methods

not :: Intensional e Bool -> Intensional e Bool

conj :: Intensional e Bool -> Intensional e Bool -> Intensional e Bool

disj :: Intensional e Bool -> Intensional e Bool -> Intensional e Bool

xor :: Intensional e Bool -> Intensional e Bool -> Intensional e Bool

FracExp e => FracExp (Intensional e)

Defined in Dino.Interpretation

Methods

fdiv :: (Fractional a, Eq a) => Intensional e a -> Intensional e a -> Intensional e a

NumExp e => NumExp (Intensional e)

Defined in Dino.Interpretation

Methods

add :: Num a => Intensional e a -> Intensional e a -> Intensional e a

sub :: Num a => Intensional e a -> Intensional e a -> Intensional e a

mul :: Num a => Intensional e a -> Intensional e a -> Intensional e a

absE :: Num a => Intensional e a -> Intensional e a

signE :: Num a => Intensional e a -> Intensional e a

fromIntegral :: (Integral a, DinoType b, Num b) => Intensional e a -> Intensional e b

floor :: (RealFrac a, DinoType b, Integral b) => Intensional e a -> Intensional e b

truncate :: (RealFrac a, DinoType b, Integral b) => Intensional e a -> Intensional e b

roundN :: RealFrac a => Int -> Intensional e a -> Intensional e a

ConstExp e => ConstExp (Intensional e)

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> Intensional e a

VarExp e => VarExp (Intensional e)

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> Intensional e a

AnnExp ann e => AnnExp ann (Intensional e :: Type -> Type)

Defined in Dino.Interpretation

Methods

ann :: ann -> Intensional e a -> Intensional e a

liftIntensional :: (e a -> e b) -> Intensional e a -> Intensional e b

liftIntensional2 :: (e a -> e b -> e c) -> Intensional e a -> Intensional e b -> Intensional e c

liftIntensional3 :: (e a -> e b -> e c -> e d) -> Intensional e a -> Intensional e b -> Intensional e c -> Intensional e d

class VarExp e where

Named variable expressions

This class is only used to internally to create intensional interpretations. It should not be exposed to the EDSL user.

Methods

varE

Arguments

:: DinoType a

=> Text

Variable name

-> e a

Create a named variable

Instances

VarExp Reified

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> Reified a

VarExp e => VarExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> CollectAssertions e a

Monad e => VarExp (EvalEnv e)

Throws EvalEnvError when variable is not in scope or has the wrong type

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> EvalEnv e a

VarExp e => VarExp (Intensional e)

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> Intensional e a

Monoid e => VarExp (Fold e)

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> Fold e a

(VarExp e1, VarExp e2) => VarExp (e1 :×: e2)

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> (e1 :×: e2) a

unbind

Arguments

:: (VarExp e, DinoType a)

=> Text

Variable base name

-> (Intensional e a -> Intensional e b)

Body parameterized by its free variable

-> (Text, Intensional e b)

Generated variable and function body

Open up a binder represented as a Haskell function

This function helps creating intensional interpretations of higher-order constructs.

unbind2

Arguments

:: (VarExp e, DinoType a, DinoType b)

=> Text

Variable base name

-> (Intensional e a -> Intensional e b -> Intensional e c)

Body parameterized by its free variables

-> (Text, Text, Intensional e c)

Generated variables and function body

A version of unbind for 2-argument functions

class CondIntensional e where

Intensional counterpart of CondExp

Methods

maybeI

Arguments

:: DinoType a

=> Text

Variable name

-> e b

-> e b

Result when just (open term)

-> e (Maybe a)

-> e b

Intensional counterpart of maybe

Instances

CondIntensional Reified

Defined in Dino.Interpretation

Methods

maybeI :: DinoType a => Text -> Reified b -> Reified b -> Reified (Maybe a) -> Reified b

Monad e => CondIntensional (EvalEnv e)

Defined in Dino.Interpretation

Methods

maybeI :: DinoType a => Text -> EvalEnv e b -> EvalEnv e b -> EvalEnv e (Maybe a) -> EvalEnv e b

Semigroup e => CondIntensional (Fold e)

Defined in Dino.Interpretation

Methods

maybeI :: DinoType a => Text -> Fold e b -> Fold e b -> Fold e (Maybe a) -> Fold e b

(CondIntensional e1, CondIntensional e2) => CondIntensional (e1 :×: e2)

Defined in Dino.Interpretation

Methods

maybeI :: DinoType a => Text -> (e1 :×: e2) b -> (e1 :×: e2) b -> (e1 :×: e2) (Maybe a) -> (e1 :×: e2) b

class ListIntensional e where

Intensional counterpart of ListExp

Methods

mapI

Arguments

:: DinoType a

=> Text

Variable name

-> e b

Body (open term)

-> e [a]

-> e [b]

Intensional counterpart of mapE

dropWhileI

Arguments

:: DinoType a

=> Text

Name of element variable

-> e Bool

Predicate body (open term)

-> e [a]

-> e [a]

Intensional counterpart of dropWhileE

foldI

Arguments

:: (DinoType a, DinoType b)

=> Text

Name of state variable

-> Text

Name of element variable

-> e a

Body (term with two free variables)

-> e a

-> e [b]

-> e a

Intensional counterpart of foldE

Instances

ListIntensional Reified

Defined in Dino.Interpretation

Methods

mapI :: DinoType a => Text -> Reified b -> Reified [a] -> Reified [b]

dropWhileI :: DinoType a => Text -> Reified Bool -> Reified [a] -> Reified [a]

foldI :: (DinoType a, DinoType b) => Text -> Text -> Reified a -> Reified a -> Reified [b] -> Reified a

Monad e => ListIntensional (EvalEnv e)

Defined in Dino.Interpretation

Methods

mapI :: DinoType a => Text -> EvalEnv e b -> EvalEnv e [a] -> EvalEnv e [b]

dropWhileI :: DinoType a => Text -> EvalEnv e Bool -> EvalEnv e [a] -> EvalEnv e [a]

foldI :: (DinoType a, DinoType b) => Text -> Text -> EvalEnv e a -> EvalEnv e a -> EvalEnv e [b] -> EvalEnv e a

Semigroup e => ListIntensional (Fold e)

Defined in Dino.Interpretation

Methods

mapI :: DinoType a => Text -> Fold e b -> Fold e [a] -> Fold e [b]

dropWhileI :: DinoType a => Text -> Fold e Bool -> Fold e [a] -> Fold e [a]

foldI :: (DinoType a, DinoType b) => Text -> Text -> Fold e a -> Fold e a -> Fold e [b] -> Fold e a

(ListIntensional e1, ListIntensional e2) => ListIntensional (e1 :×: e2)

Defined in Dino.Interpretation

Methods

mapI :: DinoType a => Text -> (e1 :×: e2) b -> (e1 :×: e2) [a] -> (e1 :×: e2) [b]

dropWhileI :: DinoType a => Text -> (e1 :×: e2) Bool -> (e1 :×: e2) [a] -> (e1 :×: e2) [a]

foldI :: (DinoType a, DinoType b) => Text -> Text -> (e1 :×: e2) a -> (e1 :×: e2) a -> (e1 :×: e2) [b] -> (e1 :×: e2) a

class LetIntensional e where

Intensional counterpart of LetExp

Methods

letI

Arguments

:: DinoType a

=> Text

Variable name

-> e a

-> e b

Body (open term)

-> e b

Intensional counterpart of letE

Instances

LetIntensional Reified

Defined in Dino.Interpretation

Methods

letI :: DinoType a => Text -> Reified a -> Reified b -> Reified b

Monad e => LetIntensional (EvalEnv e)

Defined in Dino.Interpretation

Methods

letI :: DinoType a => Text -> EvalEnv e a -> EvalEnv e b -> EvalEnv e b

Semigroup e => LetIntensional (Fold e)

Defined in Dino.Interpretation

Methods

letI :: DinoType a => Text -> Fold e a -> Fold e b -> Fold e b

(LetIntensional e1, LetIntensional e2) => LetIntensional (e1 :×: e2)

Defined in Dino.Interpretation

Methods

letI :: DinoType a => Text -> (e1 :×: e2) a -> (e1 :×: e2) b -> (e1 :×: e2) b

AST reification

newtype NumRep

Generic representation of numbers using Rational

Constructors

NumRep

Fields

• unNumRep :: Rational

Instances

Eq NumRep

Defined in Dino.Interpretation

Methods

(==) :: NumRep -> NumRep -> Bool

(/=) :: NumRep -> NumRep -> Bool

Fractional NumRep

Defined in Dino.Interpretation

Methods

(/) :: NumRep -> NumRep -> NumRep

recip :: NumRep -> NumRep

fromRational :: Rational -> NumRep

Num NumRep

Defined in Dino.Interpretation

Methods

(+) :: NumRep -> NumRep -> NumRep

(-) :: NumRep -> NumRep -> NumRep

(*) :: NumRep -> NumRep -> NumRep

negate :: NumRep -> NumRep

abs :: NumRep -> NumRep

signum :: NumRep -> NumRep

fromInteger :: Integer -> NumRep

Ord NumRep

Defined in Dino.Interpretation

Methods

compare :: NumRep -> NumRep -> Ordering

(<) :: NumRep -> NumRep -> Bool

(<=) :: NumRep -> NumRep -> Bool

(>) :: NumRep -> NumRep -> Bool

(>=) :: NumRep -> NumRep -> Bool

max :: NumRep -> NumRep -> NumRep

min :: NumRep -> NumRep -> NumRep

Real NumRep

Defined in Dino.Interpretation

Methods

toRational :: NumRep -> Rational

Show NumRep

Integers are show exactly, non-integers are shown at Double precision.

Defined in Dino.Interpretation

Methods

showsPrec :: Int -> NumRep -> ShowS

show :: NumRep -> String

showList :: [NumRep] -> ShowS

Hashable NumRep

Defined in Dino.Interpretation

Methods

hashWithSalt :: Int -> NumRep -> Int

hash :: NumRep -> Int

newtype Reified a

Expression reified as an AST

Constructors

Reified

Fields

• unReified :: AST NumRep

Instances

AssertExp Reified

Ignores the assertion

Defined in Dino.Interpretation

Methods

assert :: Text -> Reified Bool -> Reified a -> Reified a

assertEq :: (Eq a, Show a) => Text -> Reified a -> Reified a -> Reified a

FieldExp Reified

Field name prepended with #

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> Reified r -> Reified a

TupleExp Reified

Defined in Dino.Interpretation

Methods

pair :: Reified a -> Reified b -> Reified (a, b)

fstE :: Reified (a, b) -> Reified a

sndE :: Reified (a, b) -> Reified b

ListExpFO Reified

Defined in Dino.Interpretation

Methods

range :: Enum a => Reified a -> Reified a -> Reified [a]

list :: DinoType a => [Reified a] -> Reified [a]

headE :: Reified [a] -> Reified (Maybe a)

append :: Reified [a] -> Reified [a] -> Reified [a]

CondExpFO Reified

Defined in Dino.Interpretation

Methods

just :: Reified a -> Reified (Maybe a)

cases :: [Reified Bool :-> Reified a] -> (Otherwise :-> Reified a) -> Reified a

partial_cases :: HasCallStack => [Reified Bool :-> Reified a] -> Reified a

CompareExp Reified

Defined in Dino.Interpretation

Methods

eq :: Eq a => Reified a -> Reified a -> Reified Bool

neq :: Eq a => Reified a -> Reified a -> Reified Bool

lt :: Ord a => Reified a -> Reified a -> Reified Bool

gt :: Ord a => Reified a -> Reified a -> Reified Bool

lte :: Ord a => Reified a -> Reified a -> Reified Bool

gte :: Ord a => Reified a -> Reified a -> Reified Bool

min :: Ord a => Reified a -> Reified a -> Reified a

max :: Ord a => Reified a -> Reified a -> Reified a

LogicExp Reified

Defined in Dino.Interpretation

Methods

not :: Reified Bool -> Reified Bool

conj :: Reified Bool -> Reified Bool -> Reified Bool

disj :: Reified Bool -> Reified Bool -> Reified Bool

xor :: Reified Bool -> Reified Bool -> Reified Bool

FracExp Reified

Defined in Dino.Interpretation

Methods

fdiv :: (Fractional a, Eq a) => Reified a -> Reified a -> Reified a

NumExp Reified

Defined in Dino.Interpretation

Methods

add :: Num a => Reified a -> Reified a -> Reified a

sub :: Num a => Reified a -> Reified a -> Reified a

mul :: Num a => Reified a -> Reified a -> Reified a

absE :: Num a => Reified a -> Reified a

signE :: Num a => Reified a -> Reified a

fromIntegral :: (Integral a, DinoType b, Num b) => Reified a -> Reified b

floor :: (RealFrac a, DinoType b, Integral b) => Reified a -> Reified b

truncate :: (RealFrac a, DinoType b, Integral b) => Reified a -> Reified b

roundN :: RealFrac a => Int -> Reified a -> Reified a

ConstExp Reified

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> Reified a

LetIntensional Reified

Defined in Dino.Interpretation

Methods

letI :: DinoType a => Text -> Reified a -> Reified b -> Reified b

ListIntensional Reified

Defined in Dino.Interpretation

Methods

mapI :: DinoType a => Text -> Reified b -> Reified [a] -> Reified [b]

dropWhileI :: DinoType a => Text -> Reified Bool -> Reified [a] -> Reified [a]

foldI :: (DinoType a, DinoType b) => Text -> Text -> Reified a -> Reified a -> Reified [b] -> Reified a

CondIntensional Reified

Defined in Dino.Interpretation

Methods

maybeI :: DinoType a => Text -> Reified b -> Reified b -> Reified (Maybe a) -> Reified b

VarExp Reified

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> Reified a

Inspectable (Reified a)

Defined in Dino.Interpretation

Methods

inspect :: Reified a -> AST Rational

AnnExp Text Reified

Defined in Dino.Interpretation

Methods

ann :: Text -> Reified a -> Reified a

appReified :: Constr -> Reified a -> Reified b

appReified2 :: Constr -> Reified a -> Reified b -> Reified c

appReified3 :: Constr -> Reified a -> Reified b -> Reified c -> Reified d

appReified4 :: Constr -> Reified a -> Reified b -> Reified c -> Reified d -> Reified e

appReified5 :: Constr -> Reified a -> Reified b -> Reified c -> Reified d -> Reified e -> Reified f

Evaluation with variables

newtype EvalEnv e a

Interpretation wrapper that evaluates using a variable environment rather than piggybacking on higher-order syntax

EvalEnv lacks instances of HOS classes. Instead, it provides instances of 'intensional classes. In order to regain the missing HOS instances, EvalEnv 'can be wrapped in Intensional.

Intensional (EvalEnv e) is essentially equivalent to e, when e is a Monad.

The purpose of EvalEnv is to be used when evaluation must be done under Intensional. For example, this happens when combining reification and evaluation.

Constructors

EvalEnv

Fields

• unEvalEnv :: ReaderT (HashMap Text Dinamic) e a

Instances

Monad e => Monad (EvalEnv e)

Defined in Dino.Interpretation

Methods

(>>=) :: EvalEnv e a -> (a -> EvalEnv e b) -> EvalEnv e b

(>>) :: EvalEnv e a -> EvalEnv e b -> EvalEnv e b

return :: a -> EvalEnv e a

fail :: String -> EvalEnv e a

Functor e => Functor (EvalEnv e)

Defined in Dino.Interpretation

Methods

fmap :: (a -> b) -> EvalEnv e a -> EvalEnv e b

(<$) :: a -> EvalEnv e b -> EvalEnv e a

Applicative e => Applicative (EvalEnv e)

Defined in Dino.Interpretation

Methods

pure :: a -> EvalEnv e a

(<*>) :: EvalEnv e (a -> b) -> EvalEnv e a -> EvalEnv e b

liftA2 :: (a -> b -> c) -> EvalEnv e a -> EvalEnv e b -> EvalEnv e c

(*>) :: EvalEnv e a -> EvalEnv e b -> EvalEnv e b

(<*) :: EvalEnv e a -> EvalEnv e b -> EvalEnv e a

Monad e => FieldExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> EvalEnv e r -> EvalEnv e a

Monad e => TupleExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

pair :: EvalEnv e a -> EvalEnv e b -> EvalEnv e (a, b)

fstE :: EvalEnv e (a, b) -> EvalEnv e a

sndE :: EvalEnv e (a, b) -> EvalEnv e b

Monad e => ListExpFO (EvalEnv e)

Defined in Dino.Interpretation

Methods

range :: Enum a => EvalEnv e a -> EvalEnv e a -> EvalEnv e [a]

list :: DinoType a => [EvalEnv e a] -> EvalEnv e [a]

headE :: EvalEnv e [a] -> EvalEnv e (Maybe a)

append :: EvalEnv e [a] -> EvalEnv e [a] -> EvalEnv e [a]

Monad e => CondExpFO (EvalEnv e)

Defined in Dino.Interpretation

Methods

just :: EvalEnv e a -> EvalEnv e (Maybe a)

cases :: [EvalEnv e Bool :-> EvalEnv e a] -> (Otherwise :-> EvalEnv e a) -> EvalEnv e a

partial_cases :: HasCallStack => [EvalEnv e Bool :-> EvalEnv e a] -> EvalEnv e a

Applicative e => CompareExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

eq :: Eq a => EvalEnv e a -> EvalEnv e a -> EvalEnv e Bool

neq :: Eq a => EvalEnv e a -> EvalEnv e a -> EvalEnv e Bool

lt :: Ord a => EvalEnv e a -> EvalEnv e a -> EvalEnv e Bool

gt :: Ord a => EvalEnv e a -> EvalEnv e a -> EvalEnv e Bool

lte :: Ord a => EvalEnv e a -> EvalEnv e a -> EvalEnv e Bool

gte :: Ord a => EvalEnv e a -> EvalEnv e a -> EvalEnv e Bool

min :: Ord a => EvalEnv e a -> EvalEnv e a -> EvalEnv e a

max :: Ord a => EvalEnv e a -> EvalEnv e a -> EvalEnv e a

Applicative e => LogicExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

not :: EvalEnv e Bool -> EvalEnv e Bool

conj :: EvalEnv e Bool -> EvalEnv e Bool -> EvalEnv e Bool

disj :: EvalEnv e Bool -> EvalEnv e Bool -> EvalEnv e Bool

xor :: EvalEnv e Bool -> EvalEnv e Bool -> EvalEnv e Bool

Applicative e => FracExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

fdiv :: (Fractional a, Eq a) => EvalEnv e a -> EvalEnv e a -> EvalEnv e a

Applicative e => NumExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

add :: Num a => EvalEnv e a -> EvalEnv e a -> EvalEnv e a

sub :: Num a => EvalEnv e a -> EvalEnv e a -> EvalEnv e a

mul :: Num a => EvalEnv e a -> EvalEnv e a -> EvalEnv e a

absE :: Num a => EvalEnv e a -> EvalEnv e a

signE :: Num a => EvalEnv e a -> EvalEnv e a

fromIntegral :: (Integral a, DinoType b, Num b) => EvalEnv e a -> EvalEnv e b

floor :: (RealFrac a, DinoType b, Integral b) => EvalEnv e a -> EvalEnv e b

truncate :: (RealFrac a, DinoType b, Integral b) => EvalEnv e a -> EvalEnv e b

roundN :: RealFrac a => Int -> EvalEnv e a -> EvalEnv e a

Applicative e => ConstExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> EvalEnv e a

Monad e => LetIntensional (EvalEnv e)

Defined in Dino.Interpretation

Methods

letI :: DinoType a => Text -> EvalEnv e a -> EvalEnv e b -> EvalEnv e b

Monad e => ListIntensional (EvalEnv e)

Defined in Dino.Interpretation

Methods

mapI :: DinoType a => Text -> EvalEnv e b -> EvalEnv e [a] -> EvalEnv e [b]

dropWhileI :: DinoType a => Text -> EvalEnv e Bool -> EvalEnv e [a] -> EvalEnv e [a]

foldI :: (DinoType a, DinoType b) => Text -> Text -> EvalEnv e a -> EvalEnv e a -> EvalEnv e [b] -> EvalEnv e a

Monad e => CondIntensional (EvalEnv e)

Defined in Dino.Interpretation

Methods

maybeI :: DinoType a => Text -> EvalEnv e b -> EvalEnv e b -> EvalEnv e (Maybe a) -> EvalEnv e b

Monad e => VarExp (EvalEnv e)

Throws EvalEnvError when variable is not in scope or has the wrong type

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> EvalEnv e a

AnnExp ann (EvalEnv e :: Type -> Type)

Defined in Dino.Interpretation

Methods

ann :: ann -> EvalEnv e a -> EvalEnv e a

Monad e => MonadReader (HashMap Text Dinamic) (EvalEnv e)

Defined in Dino.Interpretation

Methods

ask :: EvalEnv e (HashMap Text Dinamic)

local :: (HashMap Text Dinamic -> HashMap Text Dinamic) -> EvalEnv e a -> EvalEnv e a

reader :: (HashMap Text Dinamic -> a) -> EvalEnv e a

extendEnv

Arguments

:: (Monad e, DinoType a)

=> Text

Variable name

-> a

Value of variable

-> EvalEnv e b

Expression to evaluate in modified environment

-> EvalEnv e b

Add a local variable binding

data EvalEnvError

Constructors

NotInScope Text

TypeError Text

Instances

Show EvalEnvError

Defined in Dino.Interpretation

Methods

showsPrec :: Int -> EvalEnvError -> ShowS

show :: EvalEnvError -> String

showList :: [EvalEnvError] -> ShowS

Exception EvalEnvError

Defined in Dino.Interpretation

Methods

toException :: EvalEnvError -> SomeException

fromException :: SomeException -> Maybe EvalEnvError

displayException :: EvalEnvError -> String

Checking assertions

data InvalidAssertion

Constructors

InvalidCondition

Fields

• assertionLabel :: Text

NotEqual

Fields

• assertionLabel :: Text
• reference :: Text
• actual :: Text

Instances

Show InvalidAssertion

Defined in Dino.Interpretation

Methods

showsPrec :: Int -> InvalidAssertion -> ShowS

show :: InvalidAssertion -> String

showList :: [InvalidAssertion] -> ShowS

Exception InvalidAssertion

Defined in Dino.Interpretation

Methods

toException :: InvalidAssertion -> SomeException

fromException :: SomeException -> Maybe InvalidAssertion

displayException :: InvalidAssertion -> String

newtype AssertViaMonadError e a

Interpretation wrapper whose AssertExp instance uses MonadError

Constructors

AssertViaMonadError

Fields

• unAssertViaMonadError :: e a

Instances

MonadError exc e => MonadError exc (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

throwError :: exc -> AssertViaMonadError e a

catchError :: AssertViaMonadError e a -> (exc -> AssertViaMonadError e a) -> AssertViaMonadError e a

Monad e => Monad (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

(>>=) :: AssertViaMonadError e a -> (a -> AssertViaMonadError e b) -> AssertViaMonadError e b

(>>) :: AssertViaMonadError e a -> AssertViaMonadError e b -> AssertViaMonadError e b

return :: a -> AssertViaMonadError e a

fail :: String -> AssertViaMonadError e a

Functor e => Functor (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

fmap :: (a -> b) -> AssertViaMonadError e a -> AssertViaMonadError e b

(<$) :: a -> AssertViaMonadError e b -> AssertViaMonadError e a

Applicative e => Applicative (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

pure :: a -> AssertViaMonadError e a

(<*>) :: AssertViaMonadError e (a -> b) -> AssertViaMonadError e a -> AssertViaMonadError e b

liftA2 :: (a -> b -> c) -> AssertViaMonadError e a -> AssertViaMonadError e b -> AssertViaMonadError e c

(*>) :: AssertViaMonadError e a -> AssertViaMonadError e b -> AssertViaMonadError e b

(<*) :: AssertViaMonadError e a -> AssertViaMonadError e b -> AssertViaMonadError e a

MonadError InvalidAssertion e => AssertExp (AssertViaMonadError e)

Throws InvalidAssertion in the underlying monad

Defined in Dino.Interpretation

Methods

assert :: Text -> AssertViaMonadError e Bool -> AssertViaMonadError e a -> AssertViaMonadError e a

assertEq :: (Eq a, Show a) => Text -> AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e a

FieldExp e => FieldExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> AssertViaMonadError e r -> AssertViaMonadError e a

LetExp e => LetExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

letE :: DinoType a => Text -> AssertViaMonadError e a -> (AssertViaMonadError e a -> AssertViaMonadError e b) -> AssertViaMonadError e b

TupleExp e => TupleExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

pair :: AssertViaMonadError e a -> AssertViaMonadError e b -> AssertViaMonadError e (a, b)

fstE :: AssertViaMonadError e (a, b) -> AssertViaMonadError e a

sndE :: AssertViaMonadError e (a, b) -> AssertViaMonadError e b

ListExp e => ListExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

mapE :: DinoType a => (AssertViaMonadError e a -> AssertViaMonadError e b) -> AssertViaMonadError e [a] -> AssertViaMonadError e [b]

dropWhileE :: DinoType a => (AssertViaMonadError e a -> AssertViaMonadError e Bool) -> AssertViaMonadError e [a] -> AssertViaMonadError e [a]

foldE :: (DinoType a, DinoType b) => (AssertViaMonadError e a -> AssertViaMonadError e b -> AssertViaMonadError e a) -> AssertViaMonadError e a -> AssertViaMonadError e [b] -> AssertViaMonadError e a

ListExpFO e => ListExpFO (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

range :: Enum a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e [a]

list :: DinoType a => [AssertViaMonadError e a] -> AssertViaMonadError e [a]

headE :: AssertViaMonadError e [a] -> AssertViaMonadError e (Maybe a)

append :: AssertViaMonadError e [a] -> AssertViaMonadError e [a] -> AssertViaMonadError e [a]

CondExp e => CondExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

maybe :: DinoType a => AssertViaMonadError e b -> (AssertViaMonadError e a -> AssertViaMonadError e b) -> AssertViaMonadError e (Maybe a) -> AssertViaMonadError e b

CondExpFO e => CondExpFO (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

just :: AssertViaMonadError e a -> AssertViaMonadError e (Maybe a)

cases :: [AssertViaMonadError e Bool :-> AssertViaMonadError e a] -> (Otherwise :-> AssertViaMonadError e a) -> AssertViaMonadError e a

partial_cases :: HasCallStack => [AssertViaMonadError e Bool :-> AssertViaMonadError e a] -> AssertViaMonadError e a

CompareExp e => CompareExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

eq :: Eq a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e Bool

neq :: Eq a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e Bool

lt :: Ord a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e Bool

gt :: Ord a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e Bool

lte :: Ord a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e Bool

gte :: Ord a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e Bool

min :: Ord a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e a

max :: Ord a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e a

LogicExp e => LogicExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

not :: AssertViaMonadError e Bool -> AssertViaMonadError e Bool

conj :: AssertViaMonadError e Bool -> AssertViaMonadError e Bool -> AssertViaMonadError e Bool

disj :: AssertViaMonadError e Bool -> AssertViaMonadError e Bool -> AssertViaMonadError e Bool

xor :: AssertViaMonadError e Bool -> AssertViaMonadError e Bool -> AssertViaMonadError e Bool

FracExp e => FracExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

fdiv :: (Fractional a, Eq a) => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e a

NumExp e => NumExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

add :: Num a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e a

sub :: Num a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e a

mul :: Num a => AssertViaMonadError e a -> AssertViaMonadError e a -> AssertViaMonadError e a

absE :: Num a => AssertViaMonadError e a -> AssertViaMonadError e a

signE :: Num a => AssertViaMonadError e a -> AssertViaMonadError e a

fromIntegral :: (Integral a, DinoType b, Num b) => AssertViaMonadError e a -> AssertViaMonadError e b

floor :: (RealFrac a, DinoType b, Integral b) => AssertViaMonadError e a -> AssertViaMonadError e b

truncate :: (RealFrac a, DinoType b, Integral b) => AssertViaMonadError e a -> AssertViaMonadError e b

roundN :: RealFrac a => Int -> AssertViaMonadError e a -> AssertViaMonadError e a

ConstExp e => ConstExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> AssertViaMonadError e a

AnnExp ann e => AnnExp ann (AssertViaMonadError e :: Type -> Type)

Defined in Dino.Interpretation

Methods

ann :: ann -> AssertViaMonadError e a -> AssertViaMonadError e a

newtype AssertViaMonadThrow e a

Interpretation wrapper whose AssertExp instance uses MonadThrow

Constructors

AssertViaMonadThrow

Fields

• unAssertViaMonadThrow :: e a

Instances

Monad e => Monad (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

(>>=) :: AssertViaMonadThrow e a -> (a -> AssertViaMonadThrow e b) -> AssertViaMonadThrow e b

(>>) :: AssertViaMonadThrow e a -> AssertViaMonadThrow e b -> AssertViaMonadThrow e b

return :: a -> AssertViaMonadThrow e a

fail :: String -> AssertViaMonadThrow e a

Functor e => Functor (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

fmap :: (a -> b) -> AssertViaMonadThrow e a -> AssertViaMonadThrow e b

(<$) :: a -> AssertViaMonadThrow e b -> AssertViaMonadThrow e a

Applicative e => Applicative (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

pure :: a -> AssertViaMonadThrow e a

(<*>) :: AssertViaMonadThrow e (a -> b) -> AssertViaMonadThrow e a -> AssertViaMonadThrow e b

liftA2 :: (a -> b -> c) -> AssertViaMonadThrow e a -> AssertViaMonadThrow e b -> AssertViaMonadThrow e c

(*>) :: AssertViaMonadThrow e a -> AssertViaMonadThrow e b -> AssertViaMonadThrow e b

(<*) :: AssertViaMonadThrow e a -> AssertViaMonadThrow e b -> AssertViaMonadThrow e a

MonadThrow e => MonadThrow (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

throwM :: Exception e0 => e0 -> AssertViaMonadThrow e a

MonadThrow e => AssertExp (AssertViaMonadThrow e)

Throws InvalidAssertion in the underlying monad

Defined in Dino.Interpretation

Methods

assert :: Text -> AssertViaMonadThrow e Bool -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

assertEq :: (Eq a, Show a) => Text -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

FieldExp e => FieldExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> AssertViaMonadThrow e r -> AssertViaMonadThrow e a

LetExp e => LetExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

letE :: DinoType a => Text -> AssertViaMonadThrow e a -> (AssertViaMonadThrow e a -> AssertViaMonadThrow e b) -> AssertViaMonadThrow e b

TupleExp e => TupleExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

pair :: AssertViaMonadThrow e a -> AssertViaMonadThrow e b -> AssertViaMonadThrow e (a, b)

fstE :: AssertViaMonadThrow e (a, b) -> AssertViaMonadThrow e a

sndE :: AssertViaMonadThrow e (a, b) -> AssertViaMonadThrow e b

ListExp e => ListExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

mapE :: DinoType a => (AssertViaMonadThrow e a -> AssertViaMonadThrow e b) -> AssertViaMonadThrow e [a] -> AssertViaMonadThrow e [b]

dropWhileE :: DinoType a => (AssertViaMonadThrow e a -> AssertViaMonadThrow e Bool) -> AssertViaMonadThrow e [a] -> AssertViaMonadThrow e [a]

foldE :: (DinoType a, DinoType b) => (AssertViaMonadThrow e a -> AssertViaMonadThrow e b -> AssertViaMonadThrow e a) -> AssertViaMonadThrow e a -> AssertViaMonadThrow e [b] -> AssertViaMonadThrow e a

ListExpFO e => ListExpFO (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

range :: Enum a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e [a]

list :: DinoType a => [AssertViaMonadThrow e a] -> AssertViaMonadThrow e [a]

headE :: AssertViaMonadThrow e [a] -> AssertViaMonadThrow e (Maybe a)

append :: AssertViaMonadThrow e [a] -> AssertViaMonadThrow e [a] -> AssertViaMonadThrow e [a]

CondExp e => CondExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

maybe :: DinoType a => AssertViaMonadThrow e b -> (AssertViaMonadThrow e a -> AssertViaMonadThrow e b) -> AssertViaMonadThrow e (Maybe a) -> AssertViaMonadThrow e b

CondExpFO e => CondExpFO (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

just :: AssertViaMonadThrow e a -> AssertViaMonadThrow e (Maybe a)

cases :: [AssertViaMonadThrow e Bool :-> AssertViaMonadThrow e a] -> (Otherwise :-> AssertViaMonadThrow e a) -> AssertViaMonadThrow e a

partial_cases :: HasCallStack => [AssertViaMonadThrow e Bool :-> AssertViaMonadThrow e a] -> AssertViaMonadThrow e a

CompareExp e => CompareExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

eq :: Eq a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e Bool

neq :: Eq a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e Bool

lt :: Ord a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e Bool

gt :: Ord a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e Bool

lte :: Ord a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e Bool

gte :: Ord a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e Bool

min :: Ord a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

max :: Ord a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

LogicExp e => LogicExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

not :: AssertViaMonadThrow e Bool -> AssertViaMonadThrow e Bool

conj :: AssertViaMonadThrow e Bool -> AssertViaMonadThrow e Bool -> AssertViaMonadThrow e Bool

disj :: AssertViaMonadThrow e Bool -> AssertViaMonadThrow e Bool -> AssertViaMonadThrow e Bool

xor :: AssertViaMonadThrow e Bool -> AssertViaMonadThrow e Bool -> AssertViaMonadThrow e Bool

FracExp e => FracExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

fdiv :: (Fractional a, Eq a) => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

NumExp e => NumExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

add :: Num a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

sub :: Num a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

mul :: Num a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

absE :: Num a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a

signE :: Num a => AssertViaMonadThrow e a -> AssertViaMonadThrow e a

fromIntegral :: (Integral a, DinoType b, Num b) => AssertViaMonadThrow e a -> AssertViaMonadThrow e b

floor :: (RealFrac a, DinoType b, Integral b) => AssertViaMonadThrow e a -> AssertViaMonadThrow e b

truncate :: (RealFrac a, DinoType b, Integral b) => AssertViaMonadThrow e a -> AssertViaMonadThrow e b

roundN :: RealFrac a => Int -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

ConstExp e => ConstExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> AssertViaMonadThrow e a

AnnExp ann e => AnnExp ann (AssertViaMonadThrow e :: Type -> Type)

Defined in Dino.Interpretation

Methods

ann :: ann -> AssertViaMonadThrow e a -> AssertViaMonadThrow e a

data Assertion e where

Constructors

Assert :: e Bool -> Assertion e

AssertEq :: (Eq a, Show a) => e a -> e a -> Assertion e

newtype CollectAssertions e a

Collect all assertions in an expression

Note that the wrapped interpretation e must have instances of intensional classes in order for CollectAssertions to derive instances of HOS classes. In order for the wrapped interpretation to do monadic evaluation, use the wrapper EvalEnv to obtain the necessary intensional instances.

Constructors

CollectAssertions

Fields

• unCollectAssertions :: Intensional (e :×: Fold [(Text, Assertion e)]) a

Instances

AssertExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

assert :: Text -> CollectAssertions e Bool -> CollectAssertions e a -> CollectAssertions e a

assertEq :: (Eq a, Show a) => Text -> CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e a

FieldExp e => FieldExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> CollectAssertions e r -> CollectAssertions e a

(VarExp e, LetIntensional e) => LetExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

letE :: DinoType a => Text -> CollectAssertions e a -> (CollectAssertions e a -> CollectAssertions e b) -> CollectAssertions e b

TupleExp e => TupleExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

pair :: CollectAssertions e a -> CollectAssertions e b -> CollectAssertions e (a, b)

fstE :: CollectAssertions e (a, b) -> CollectAssertions e a

sndE :: CollectAssertions e (a, b) -> CollectAssertions e b

(ListExpFO e, VarExp e, ListIntensional e) => ListExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

mapE :: DinoType a => (CollectAssertions e a -> CollectAssertions e b) -> CollectAssertions e [a] -> CollectAssertions e [b]

dropWhileE :: DinoType a => (CollectAssertions e a -> CollectAssertions e Bool) -> CollectAssertions e [a] -> CollectAssertions e [a]

foldE :: (DinoType a, DinoType b) => (CollectAssertions e a -> CollectAssertions e b -> CollectAssertions e a) -> CollectAssertions e a -> CollectAssertions e [b] -> CollectAssertions e a

ListExpFO e => ListExpFO (CollectAssertions e)

Defined in Dino.Interpretation

Methods

range :: Enum a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e [a]

list :: DinoType a => [CollectAssertions e a] -> CollectAssertions e [a]

headE :: CollectAssertions e [a] -> CollectAssertions e (Maybe a)

append :: CollectAssertions e [a] -> CollectAssertions e [a] -> CollectAssertions e [a]

(CondExpFO e, VarExp e, CondIntensional e) => CondExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

maybe :: DinoType a => CollectAssertions e b -> (CollectAssertions e a -> CollectAssertions e b) -> CollectAssertions e (Maybe a) -> CollectAssertions e b

CondExpFO e => CondExpFO (CollectAssertions e)

Defined in Dino.Interpretation

Methods

just :: CollectAssertions e a -> CollectAssertions e (Maybe a)

cases :: [CollectAssertions e Bool :-> CollectAssertions e a] -> (Otherwise :-> CollectAssertions e a) -> CollectAssertions e a

partial_cases :: HasCallStack => [CollectAssertions e Bool :-> CollectAssertions e a] -> CollectAssertions e a

CompareExp e => CompareExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

eq :: Eq a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e Bool

neq :: Eq a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e Bool

lt :: Ord a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e Bool

gt :: Ord a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e Bool

lte :: Ord a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e Bool

gte :: Ord a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e Bool

min :: Ord a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e a

max :: Ord a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e a

LogicExp e => LogicExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

not :: CollectAssertions e Bool -> CollectAssertions e Bool

conj :: CollectAssertions e Bool -> CollectAssertions e Bool -> CollectAssertions e Bool

disj :: CollectAssertions e Bool -> CollectAssertions e Bool -> CollectAssertions e Bool

xor :: CollectAssertions e Bool -> CollectAssertions e Bool -> CollectAssertions e Bool

FracExp e => FracExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

fdiv :: (Fractional a, Eq a) => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e a

NumExp e => NumExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

add :: Num a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e a

sub :: Num a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e a

mul :: Num a => CollectAssertions e a -> CollectAssertions e a -> CollectAssertions e a

absE :: Num a => CollectAssertions e a -> CollectAssertions e a

signE :: Num a => CollectAssertions e a -> CollectAssertions e a

fromIntegral :: (Integral a, DinoType b, Num b) => CollectAssertions e a -> CollectAssertions e b

floor :: (RealFrac a, DinoType b, Integral b) => CollectAssertions e a -> CollectAssertions e b

truncate :: (RealFrac a, DinoType b, Integral b) => CollectAssertions e a -> CollectAssertions e b

roundN :: RealFrac a => Int -> CollectAssertions e a -> CollectAssertions e a

ConstExp e => ConstExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> CollectAssertions e a

VarExp e => VarExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

varE :: DinoType a => Text -> CollectAssertions e a

AnnExp ann e => AnnExp ann (CollectAssertions e :: Type -> Type)

Defined in Dino.Interpretation

Methods

ann :: ann -> CollectAssertions e a -> CollectAssertions e a

Orphan instances

AssertExp Maybe

Ignoring assertion for efficiency

Methods

assert :: Text -> Maybe Bool -> Maybe a -> Maybe a

assertEq :: (Eq a, Show a) => Text -> Maybe a -> Maybe a -> Maybe a

AssertExp Identity

Ignoring assertion for efficiency

Methods

assert :: Text -> Identity Bool -> Identity a -> Identity a

assertEq :: (Eq a, Show a) => Text -> Identity a -> Identity a -> Identity a

AssertExp DinoTypeRep

Methods

assert :: Text -> DinoTypeRep Bool -> DinoTypeRep a -> DinoTypeRep a

assertEq :: (Eq a, Show a) => Text -> DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep a

FieldExp Maybe

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> Maybe r -> Maybe a

FieldExp Identity

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> Identity r -> Identity a

FieldExp DinoTypeRep

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> DinoTypeRep r -> DinoTypeRep a

LetExp Maybe

Methods

letE :: DinoType a => Text -> Maybe a -> (Maybe a -> Maybe b) -> Maybe b

LetExp Identity

Methods

letE :: DinoType a => Text -> Identity a -> (Identity a -> Identity b) -> Identity b

LetExp DinoTypeRep

Methods

letE :: DinoType a => Text -> DinoTypeRep a -> (DinoTypeRep a -> DinoTypeRep b) -> DinoTypeRep b

TupleExp Maybe

Methods

pair :: Maybe a -> Maybe b -> Maybe (a, b)

fstE :: Maybe (a, b) -> Maybe a

sndE :: Maybe (a, b) -> Maybe b

TupleExp Identity

Methods

pair :: Identity a -> Identity b -> Identity (a, b)

fstE :: Identity (a, b) -> Identity a

sndE :: Identity (a, b) -> Identity b

TupleExp DinoTypeRep

Methods

pair :: DinoTypeRep a -> DinoTypeRep b -> DinoTypeRep (a, b)

fstE :: DinoTypeRep (a, b) -> DinoTypeRep a

sndE :: DinoTypeRep (a, b) -> DinoTypeRep b

ListExp Maybe

Methods

mapE :: DinoType a => (Maybe a -> Maybe b) -> Maybe [a] -> Maybe [b]

dropWhileE :: DinoType a => (Maybe a -> Maybe Bool) -> Maybe [a] -> Maybe [a]

foldE :: (DinoType a, DinoType b) => (Maybe a -> Maybe b -> Maybe a) -> Maybe a -> Maybe [b] -> Maybe a

ListExp Identity

Methods

mapE :: DinoType a => (Identity a -> Identity b) -> Identity [a] -> Identity [b]

dropWhileE :: DinoType a => (Identity a -> Identity Bool) -> Identity [a] -> Identity [a]

foldE :: (DinoType a, DinoType b) => (Identity a -> Identity b -> Identity a) -> Identity a -> Identity [b] -> Identity a

ListExp DinoTypeRep

Methods

mapE :: DinoType a => (DinoTypeRep a -> DinoTypeRep b) -> DinoTypeRep [a] -> DinoTypeRep [b]

dropWhileE :: DinoType a => (DinoTypeRep a -> DinoTypeRep Bool) -> DinoTypeRep [a] -> DinoTypeRep [a]

foldE :: (DinoType a, DinoType b) => (DinoTypeRep a -> DinoTypeRep b -> DinoTypeRep a) -> DinoTypeRep a -> DinoTypeRep [b] -> DinoTypeRep a

ListExpFO Maybe

Methods

range :: Enum a => Maybe a -> Maybe a -> Maybe [a]

list :: DinoType a => [Maybe a] -> Maybe [a]

headE :: Maybe [a] -> Maybe (Maybe a)

append :: Maybe [a] -> Maybe [a] -> Maybe [a]

ListExpFO Identity

Methods

range :: Enum a => Identity a -> Identity a -> Identity [a]

list :: DinoType a => [Identity a] -> Identity [a]

headE :: Identity [a] -> Identity (Maybe a)

append :: Identity [a] -> Identity [a] -> Identity [a]

ListExpFO DinoTypeRep

Methods

range :: Enum a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep [a]

list :: DinoType a => [DinoTypeRep a] -> DinoTypeRep [a]

headE :: DinoTypeRep [a] -> DinoTypeRep (Maybe a)

append :: DinoTypeRep [a] -> DinoTypeRep [a] -> DinoTypeRep [a]

CondExp Maybe

Methods

maybe :: DinoType a => Maybe b -> (Maybe a -> Maybe b) -> Maybe (Maybe a) -> Maybe b

CondExp Identity

Methods

maybe :: DinoType a => Identity b -> (Identity a -> Identity b) -> Identity (Maybe a) -> Identity b

CondExp DinoTypeRep

Methods

maybe :: DinoType a => DinoTypeRep b -> (DinoTypeRep a -> DinoTypeRep b) -> DinoTypeRep (Maybe a) -> DinoTypeRep b

CondExpFO Maybe

Methods

just :: Maybe a -> Maybe (Maybe a)

cases :: [Maybe Bool :-> Maybe a] -> (Otherwise :-> Maybe a) -> Maybe a

partial_cases :: HasCallStack => [Maybe Bool :-> Maybe a] -> Maybe a

CondExpFO Identity

Methods

just :: Identity a -> Identity (Maybe a)

cases :: [Identity Bool :-> Identity a] -> (Otherwise :-> Identity a) -> Identity a

partial_cases :: HasCallStack => [Identity Bool :-> Identity a] -> Identity a

CondExpFO DinoTypeRep

Methods

just :: DinoTypeRep a -> DinoTypeRep (Maybe a)

cases :: [DinoTypeRep Bool :-> DinoTypeRep a] -> (Otherwise :-> DinoTypeRep a) -> DinoTypeRep a

partial_cases :: HasCallStack => [DinoTypeRep Bool :-> DinoTypeRep a] -> DinoTypeRep a

CompareExp Maybe

Methods

eq :: Eq a => Maybe a -> Maybe a -> Maybe Bool

neq :: Eq a => Maybe a -> Maybe a -> Maybe Bool

lt :: Ord a => Maybe a -> Maybe a -> Maybe Bool

gt :: Ord a => Maybe a -> Maybe a -> Maybe Bool

lte :: Ord a => Maybe a -> Maybe a -> Maybe Bool

gte :: Ord a => Maybe a -> Maybe a -> Maybe Bool

min :: Ord a => Maybe a -> Maybe a -> Maybe a

max :: Ord a => Maybe a -> Maybe a -> Maybe a

CompareExp Identity

Methods

eq :: Eq a => Identity a -> Identity a -> Identity Bool

neq :: Eq a => Identity a -> Identity a -> Identity Bool

lt :: Ord a => Identity a -> Identity a -> Identity Bool

gt :: Ord a => Identity a -> Identity a -> Identity Bool

lte :: Ord a => Identity a -> Identity a -> Identity Bool

gte :: Ord a => Identity a -> Identity a -> Identity Bool

min :: Ord a => Identity a -> Identity a -> Identity a

max :: Ord a => Identity a -> Identity a -> Identity a

CompareExp DinoTypeRep

Methods

eq :: Eq a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep Bool

neq :: Eq a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep Bool

lt :: Ord a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep Bool

gt :: Ord a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep Bool

lte :: Ord a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep Bool

gte :: Ord a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep Bool

min :: Ord a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep a

max :: Ord a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep a

LogicExp Maybe

Methods

not :: Maybe Bool -> Maybe Bool

conj :: Maybe Bool -> Maybe Bool -> Maybe Bool

disj :: Maybe Bool -> Maybe Bool -> Maybe Bool

xor :: Maybe Bool -> Maybe Bool -> Maybe Bool

LogicExp Identity

Methods

not :: Identity Bool -> Identity Bool

conj :: Identity Bool -> Identity Bool -> Identity Bool

disj :: Identity Bool -> Identity Bool -> Identity Bool

xor :: Identity Bool -> Identity Bool -> Identity Bool

LogicExp DinoTypeRep

Methods

not :: DinoTypeRep Bool -> DinoTypeRep Bool

conj :: DinoTypeRep Bool -> DinoTypeRep Bool -> DinoTypeRep Bool

disj :: DinoTypeRep Bool -> DinoTypeRep Bool -> DinoTypeRep Bool

xor :: DinoTypeRep Bool -> DinoTypeRep Bool -> DinoTypeRep Bool

FracExp Maybe

Methods

fdiv :: (Fractional a, Eq a) => Maybe a -> Maybe a -> Maybe a

FracExp Identity

Methods

fdiv :: (Fractional a, Eq a) => Identity a -> Identity a -> Identity a

FracExp DinoTypeRep

Methods

fdiv :: (Fractional a, Eq a) => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep a

NumExp Maybe

Methods

add :: Num a => Maybe a -> Maybe a -> Maybe a

sub :: Num a => Maybe a -> Maybe a -> Maybe a

mul :: Num a => Maybe a -> Maybe a -> Maybe a

absE :: Num a => Maybe a -> Maybe a

signE :: Num a => Maybe a -> Maybe a

fromIntegral :: (Integral a, DinoType b, Num b) => Maybe a -> Maybe b

floor :: (RealFrac a, DinoType b, Integral b) => Maybe a -> Maybe b

truncate :: (RealFrac a, DinoType b, Integral b) => Maybe a -> Maybe b

roundN :: RealFrac a => Int -> Maybe a -> Maybe a

NumExp Identity

Methods

add :: Num a => Identity a -> Identity a -> Identity a

sub :: Num a => Identity a -> Identity a -> Identity a

mul :: Num a => Identity a -> Identity a -> Identity a

absE :: Num a => Identity a -> Identity a

signE :: Num a => Identity a -> Identity a

fromIntegral :: (Integral a, DinoType b, Num b) => Identity a -> Identity b

floor :: (RealFrac a, DinoType b, Integral b) => Identity a -> Identity b

truncate :: (RealFrac a, DinoType b, Integral b) => Identity a -> Identity b

roundN :: RealFrac a => Int -> Identity a -> Identity a

NumExp DinoTypeRep

Methods

add :: Num a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep a

sub :: Num a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep a

mul :: Num a => DinoTypeRep a -> DinoTypeRep a -> DinoTypeRep a

absE :: Num a => DinoTypeRep a -> DinoTypeRep a

signE :: Num a => DinoTypeRep a -> DinoTypeRep a

fromIntegral :: (Integral a, DinoType b, Num b) => DinoTypeRep a -> DinoTypeRep b

floor :: (RealFrac a, DinoType b, Integral b) => DinoTypeRep a -> DinoTypeRep b

truncate :: (RealFrac a, DinoType b, Integral b) => DinoTypeRep a -> DinoTypeRep b

roundN :: RealFrac a => Int -> DinoTypeRep a -> DinoTypeRep a

ConstExp Maybe

Methods

lit :: DinoType a => a -> Maybe a

ConstExp Identity

Methods

lit :: DinoType a => a -> Identity a

ConstExp DinoTypeRep

Methods

lit :: DinoType a => a -> DinoTypeRep a

AssertExp (Either e)

Ignoring assertion for efficiency

Methods

assert :: Text -> Either e Bool -> Either e a -> Either e a

assertEq :: (Eq a, Show a) => Text -> Either e a -> Either e a -> Either e a

FieldExp (Either e)

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> Either e r -> Either e a

LetExp (Either e)

Methods

letE :: DinoType a => Text -> Either e a -> (Either e a -> Either e b) -> Either e b

TupleExp (Either e)

Methods

pair :: Either e a -> Either e b -> Either e (a, b)

fstE :: Either e (a, b) -> Either e a

sndE :: Either e (a, b) -> Either e b

ListExp (Either e)

Methods

mapE :: DinoType a => (Either e a -> Either e b) -> Either e [a] -> Either e [b]

dropWhileE :: DinoType a => (Either e a -> Either e Bool) -> Either e [a] -> Either e [a]

foldE :: (DinoType a, DinoType b) => (Either e a -> Either e b -> Either e a) -> Either e a -> Either e [b] -> Either e a

ListExpFO (Either e)

Methods

range :: Enum a => Either e a -> Either e a -> Either e [a]

list :: DinoType a => [Either e a] -> Either e [a]

headE :: Either e [a] -> Either e (Maybe a)

append :: Either e [a] -> Either e [a] -> Either e [a]

CondExp (Either e)

Methods

maybe :: DinoType a => Either e b -> (Either e a -> Either e b) -> Either e (Maybe a) -> Either e b

CondExpFO (Either e)

Methods

just :: Either e a -> Either e (Maybe a)

cases :: [Either e Bool :-> Either e a] -> (Otherwise :-> Either e a) -> Either e a

partial_cases :: HasCallStack => [Either e Bool :-> Either e a] -> Either e a

CompareExp (Either e)

Methods

eq :: Eq a => Either e a -> Either e a -> Either e Bool

neq :: Eq a => Either e a -> Either e a -> Either e Bool

lt :: Ord a => Either e a -> Either e a -> Either e Bool

gt :: Ord a => Either e a -> Either e a -> Either e Bool

lte :: Ord a => Either e a -> Either e a -> Either e Bool

gte :: Ord a => Either e a -> Either e a -> Either e Bool

min :: Ord a => Either e a -> Either e a -> Either e a

max :: Ord a => Either e a -> Either e a -> Either e a

LogicExp (Either e)

Methods

not :: Either e Bool -> Either e Bool

conj :: Either e Bool -> Either e Bool -> Either e Bool

disj :: Either e Bool -> Either e Bool -> Either e Bool

xor :: Either e Bool -> Either e Bool -> Either e Bool

FracExp (Either e)

Methods

fdiv :: (Fractional a, Eq a) => Either e a -> Either e a -> Either e a

NumExp (Either e)

Methods

add :: Num a => Either e a -> Either e a -> Either e a

sub :: Num a => Either e a -> Either e a -> Either e a

mul :: Num a => Either e a -> Either e a -> Either e a

absE :: Num a => Either e a -> Either e a

signE :: Num a => Either e a -> Either e a

fromIntegral :: (Integral a, DinoType b, Num b) => Either e a -> Either e b

floor :: (RealFrac a, DinoType b, Integral b) => Either e a -> Either e b

truncate :: (RealFrac a, DinoType b, Integral b) => Either e a -> Either e b

roundN :: RealFrac a => Int -> Either e a -> Either e a

ConstExp (Either e)

Methods

lit :: DinoType a => a -> Either e a

AnnExp ann Maybe

Methods

ann :: ann -> Maybe a -> Maybe a

AnnExp ann Identity

Methods

ann :: ann -> Identity a -> Identity a

AnnExp ann DinoTypeRep

Methods

ann :: ann -> DinoTypeRep a -> DinoTypeRep a

AnnExp ann (Either e :: Type -> Type)

Methods

ann :: ann -> Either e a -> Either e a

AnnExp ann (WriterT t m :: Type -> Type)

Methods

ann :: ann -> WriterT t m a -> WriterT t m a

AnnExp ann (ExceptT e m :: Type -> Type)

Methods

ann :: ann -> ExceptT e m a -> ExceptT e m a

AnnExp ann (ReaderT env m :: Type -> Type)

Methods

ann :: ann -> ReaderT env m a -> ReaderT env m a

AssertExp (ExceptT e m)

Ignoring assertion for efficiency

Methods

assert :: Text -> ExceptT e m Bool -> ExceptT e m a -> ExceptT e m a

assertEq :: (Eq a, Show a) => Text -> ExceptT e m a -> ExceptT e m a -> ExceptT e m a

AssertExp (WriterT t m)

Ignoring assertion for efficiency

Methods

assert :: Text -> WriterT t m Bool -> WriterT t m a -> WriterT t m a

assertEq :: (Eq a, Show a) => Text -> WriterT t m a -> WriterT t m a -> WriterT t m a

Monad m => FieldExp (ExceptT e m)

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> ExceptT e m r -> ExceptT e m a

(Monoid t, Monad m) => FieldExp (WriterT t m)

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> WriterT t m r -> WriterT t m a

Monad m => LetExp (ExceptT e m)

Methods

letE :: DinoType a => Text -> ExceptT e m a -> (ExceptT e m a -> ExceptT e m b) -> ExceptT e m b

(Monoid t, Monad m) => LetExp (WriterT t m)

Methods

letE :: DinoType a => Text -> WriterT t m a -> (WriterT t m a -> WriterT t m b) -> WriterT t m b

Monad m => TupleExp (ExceptT e m)

Methods

pair :: ExceptT e m a -> ExceptT e m b -> ExceptT e m (a, b)

fstE :: ExceptT e m (a, b) -> ExceptT e m a

sndE :: ExceptT e m (a, b) -> ExceptT e m b

(Monoid t, Monad m) => TupleExp (WriterT t m)

Methods

pair :: WriterT t m a -> WriterT t m b -> WriterT t m (a, b)

fstE :: WriterT t m (a, b) -> WriterT t m a

sndE :: WriterT t m (a, b) -> WriterT t m b

Monad m => ListExp (ExceptT e m)

Methods

mapE :: DinoType a => (ExceptT e m a -> ExceptT e m b) -> ExceptT e m [a] -> ExceptT e m [b]

dropWhileE :: DinoType a => (ExceptT e m a -> ExceptT e m Bool) -> ExceptT e m [a] -> ExceptT e m [a]

foldE :: (DinoType a, DinoType b) => (ExceptT e m a -> ExceptT e m b -> ExceptT e m a) -> ExceptT e m a -> ExceptT e m [b] -> ExceptT e m a

(Monoid t, Monad m) => ListExp (WriterT t m)

Methods

mapE :: DinoType a => (WriterT t m a -> WriterT t m b) -> WriterT t m [a] -> WriterT t m [b]

dropWhileE :: DinoType a => (WriterT t m a -> WriterT t m Bool) -> WriterT t m [a] -> WriterT t m [a]

foldE :: (DinoType a, DinoType b) => (WriterT t m a -> WriterT t m b -> WriterT t m a) -> WriterT t m a -> WriterT t m [b] -> WriterT t m a

Monad m => ListExpFO (ExceptT e m)

Methods

range :: Enum a => ExceptT e m a -> ExceptT e m a -> ExceptT e m [a]

list :: DinoType a => [ExceptT e m a] -> ExceptT e m [a]

headE :: ExceptT e m [a] -> ExceptT e m (Maybe a)

append :: ExceptT e m [a] -> ExceptT e m [a] -> ExceptT e m [a]

(Monoid t, Monad m) => ListExpFO (WriterT t m)

Methods

range :: Enum a => WriterT t m a -> WriterT t m a -> WriterT t m [a]

list :: DinoType a => [WriterT t m a] -> WriterT t m [a]

headE :: WriterT t m [a] -> WriterT t m (Maybe a)

append :: WriterT t m [a] -> WriterT t m [a] -> WriterT t m [a]

Monad m => CondExp (ExceptT e m)

Methods

maybe :: DinoType a => ExceptT e m b -> (ExceptT e m a -> ExceptT e m b) -> ExceptT e m (Maybe a) -> ExceptT e m b

(Monoid t, Monad m) => CondExp (WriterT t m)

Methods

maybe :: DinoType a => WriterT t m b -> (WriterT t m a -> WriterT t m b) -> WriterT t m (Maybe a) -> WriterT t m b

Monad m => CondExpFO (ExceptT e m)

Methods

just :: ExceptT e m a -> ExceptT e m (Maybe a)

cases :: [ExceptT e m Bool :-> ExceptT e m a] -> (Otherwise :-> ExceptT e m a) -> ExceptT e m a

partial_cases :: HasCallStack => [ExceptT e m Bool :-> ExceptT e m a] -> ExceptT e m a

(Monoid t, Monad m) => CondExpFO (WriterT t m)

Methods

just :: WriterT t m a -> WriterT t m (Maybe a)

cases :: [WriterT t m Bool :-> WriterT t m a] -> (Otherwise :-> WriterT t m a) -> WriterT t m a

partial_cases :: HasCallStack => [WriterT t m Bool :-> WriterT t m a] -> WriterT t m a

Monad m => CompareExp (ExceptT e m)

Methods

eq :: Eq a => ExceptT e m a -> ExceptT e m a -> ExceptT e m Bool

neq :: Eq a => ExceptT e m a -> ExceptT e m a -> ExceptT e m Bool

lt :: Ord a => ExceptT e m a -> ExceptT e m a -> ExceptT e m Bool

gt :: Ord a => ExceptT e m a -> ExceptT e m a -> ExceptT e m Bool

lte :: Ord a => ExceptT e m a -> ExceptT e m a -> ExceptT e m Bool

gte :: Ord a => ExceptT e m a -> ExceptT e m a -> ExceptT e m Bool

min :: Ord a => ExceptT e m a -> ExceptT e m a -> ExceptT e m a

max :: Ord a => ExceptT e m a -> ExceptT e m a -> ExceptT e m a

(Monoid t, Applicative m) => CompareExp (WriterT t m)

Methods

eq :: Eq a => WriterT t m a -> WriterT t m a -> WriterT t m Bool

neq :: Eq a => WriterT t m a -> WriterT t m a -> WriterT t m Bool

lt :: Ord a => WriterT t m a -> WriterT t m a -> WriterT t m Bool

gt :: Ord a => WriterT t m a -> WriterT t m a -> WriterT t m Bool

lte :: Ord a => WriterT t m a -> WriterT t m a -> WriterT t m Bool

gte :: Ord a => WriterT t m a -> WriterT t m a -> WriterT t m Bool

min :: Ord a => WriterT t m a -> WriterT t m a -> WriterT t m a

max :: Ord a => WriterT t m a -> WriterT t m a -> WriterT t m a

Monad m => LogicExp (ExceptT e m)

Methods

not :: ExceptT e m Bool -> ExceptT e m Bool

conj :: ExceptT e m Bool -> ExceptT e m Bool -> ExceptT e m Bool

disj :: ExceptT e m Bool -> ExceptT e m Bool -> ExceptT e m Bool

xor :: ExceptT e m Bool -> ExceptT e m Bool -> ExceptT e m Bool

(Monoid t, Applicative m) => LogicExp (WriterT t m)

Methods

not :: WriterT t m Bool -> WriterT t m Bool

conj :: WriterT t m Bool -> WriterT t m Bool -> WriterT t m Bool

disj :: WriterT t m Bool -> WriterT t m Bool -> WriterT t m Bool

xor :: WriterT t m Bool -> WriterT t m Bool -> WriterT t m Bool

Monad m => FracExp (ExceptT e m)

Methods

fdiv :: (Fractional a, Eq a) => ExceptT e m a -> ExceptT e m a -> ExceptT e m a

(Monoid t, Applicative m) => FracExp (WriterT t m)

Methods

fdiv :: (Fractional a, Eq a) => WriterT t m a -> WriterT t m a -> WriterT t m a

Monad m => NumExp (ExceptT e m)

Methods

add :: Num a => ExceptT e m a -> ExceptT e m a -> ExceptT e m a

sub :: Num a => ExceptT e m a -> ExceptT e m a -> ExceptT e m a

mul :: Num a => ExceptT e m a -> ExceptT e m a -> ExceptT e m a

absE :: Num a => ExceptT e m a -> ExceptT e m a

signE :: Num a => ExceptT e m a -> ExceptT e m a

fromIntegral :: (Integral a, DinoType b, Num b) => ExceptT e m a -> ExceptT e m b

floor :: (RealFrac a, DinoType b, Integral b) => ExceptT e m a -> ExceptT e m b

truncate :: (RealFrac a, DinoType b, Integral b) => ExceptT e m a -> ExceptT e m b

roundN :: RealFrac a => Int -> ExceptT e m a -> ExceptT e m a

(Monoid t, Applicative m) => NumExp (WriterT t m)

Methods

add :: Num a => WriterT t m a -> WriterT t m a -> WriterT t m a

sub :: Num a => WriterT t m a -> WriterT t m a -> WriterT t m a

mul :: Num a => WriterT t m a -> WriterT t m a -> WriterT t m a

absE :: Num a => WriterT t m a -> WriterT t m a

signE :: Num a => WriterT t m a -> WriterT t m a

fromIntegral :: (Integral a, DinoType b, Num b) => WriterT t m a -> WriterT t m b

floor :: (RealFrac a, DinoType b, Integral b) => WriterT t m a -> WriterT t m b

truncate :: (RealFrac a, DinoType b, Integral b) => WriterT t m a -> WriterT t m b

roundN :: RealFrac a => Int -> WriterT t m a -> WriterT t m a

Monad m => ConstExp (ExceptT e m)

Methods

lit :: DinoType a => a -> ExceptT e m a

(Monoid t, Applicative m) => ConstExp (WriterT t m)

Methods

lit :: DinoType a => a -> WriterT t m a

AssertExp (ReaderT env m)

Ignoring assertion for efficiency

Methods

assert :: Text -> ReaderT env m Bool -> ReaderT env m a -> ReaderT env m a

assertEq :: (Eq a, Show a) => Text -> ReaderT env m a -> ReaderT env m a -> ReaderT env m a

Monad m => FieldExp (ReaderT env m)

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> ReaderT env m r -> ReaderT env m a

Monad m => LetExp (ReaderT env m)

Methods

letE :: DinoType a => Text -> ReaderT env m a -> (ReaderT env m a -> ReaderT env m b) -> ReaderT env m b

Monad m => TupleExp (ReaderT env m)

Methods

pair :: ReaderT env m a -> ReaderT env m b -> ReaderT env m (a, b)

fstE :: ReaderT env m (a, b) -> ReaderT env m a

sndE :: ReaderT env m (a, b) -> ReaderT env m b

Monad m => ListExp (ReaderT env m)

Methods

mapE :: DinoType a => (ReaderT env m a -> ReaderT env m b) -> ReaderT env m [a] -> ReaderT env m [b]

dropWhileE :: DinoType a => (ReaderT env m a -> ReaderT env m Bool) -> ReaderT env m [a] -> ReaderT env m [a]

foldE :: (DinoType a, DinoType b) => (ReaderT env m a -> ReaderT env m b -> ReaderT env m a) -> ReaderT env m a -> ReaderT env m [b] -> ReaderT env m a

Monad m => ListExpFO (ReaderT env m)

Methods

range :: Enum a => ReaderT env m a -> ReaderT env m a -> ReaderT env m [a]

list :: DinoType a => [ReaderT env m a] -> ReaderT env m [a]

headE :: ReaderT env m [a] -> ReaderT env m (Maybe a)

append :: ReaderT env m [a] -> ReaderT env m [a] -> ReaderT env m [a]

Monad m => CondExp (ReaderT env m)

Methods

maybe :: DinoType a => ReaderT env m b -> (ReaderT env m a -> ReaderT env m b) -> ReaderT env m (Maybe a) -> ReaderT env m b

Monad m => CondExpFO (ReaderT env m)

Methods

just :: ReaderT env m a -> ReaderT env m (Maybe a)

cases :: [ReaderT env m Bool :-> ReaderT env m a] -> (Otherwise :-> ReaderT env m a) -> ReaderT env m a

partial_cases :: HasCallStack => [ReaderT env m Bool :-> ReaderT env m a] -> ReaderT env m a

Applicative m => CompareExp (ReaderT env m)

Methods

eq :: Eq a => ReaderT env m a -> ReaderT env m a -> ReaderT env m Bool

neq :: Eq a => ReaderT env m a -> ReaderT env m a -> ReaderT env m Bool

lt :: Ord a => ReaderT env m a -> ReaderT env m a -> ReaderT env m Bool

gt :: Ord a => ReaderT env m a -> ReaderT env m a -> ReaderT env m Bool

lte :: Ord a => ReaderT env m a -> ReaderT env m a -> ReaderT env m Bool

gte :: Ord a => ReaderT env m a -> ReaderT env m a -> ReaderT env m Bool

min :: Ord a => ReaderT env m a -> ReaderT env m a -> ReaderT env m a

max :: Ord a => ReaderT env m a -> ReaderT env m a -> ReaderT env m a

Applicative m => LogicExp (ReaderT env m)

Methods

not :: ReaderT env m Bool -> ReaderT env m Bool

conj :: ReaderT env m Bool -> ReaderT env m Bool -> ReaderT env m Bool

disj :: ReaderT env m Bool -> ReaderT env m Bool -> ReaderT env m Bool

xor :: ReaderT env m Bool -> ReaderT env m Bool -> ReaderT env m Bool

Applicative m => FracExp (ReaderT env m)

Methods

fdiv :: (Fractional a, Eq a) => ReaderT env m a -> ReaderT env m a -> ReaderT env m a

Applicative m => NumExp (ReaderT env m)

Methods

add :: Num a => ReaderT env m a -> ReaderT env m a -> ReaderT env m a

sub :: Num a => ReaderT env m a -> ReaderT env m a -> ReaderT env m a

mul :: Num a => ReaderT env m a -> ReaderT env m a -> ReaderT env m a

absE :: Num a => ReaderT env m a -> ReaderT env m a

signE :: Num a => ReaderT env m a -> ReaderT env m a

fromIntegral :: (Integral a, DinoType b, Num b) => ReaderT env m a -> ReaderT env m b

floor :: (RealFrac a, DinoType b, Integral b) => ReaderT env m a -> ReaderT env m b

truncate :: (RealFrac a, DinoType b, Integral b) => ReaderT env m a -> ReaderT env m b

roundN :: RealFrac a => Int -> ReaderT env m a -> ReaderT env m a

Applicative m => ConstExp (ReaderT env m)

Methods

lit :: DinoType a => a -> ReaderT env m a