Dino.Expression

General tagless expressions

Expression classes and constructs

Constants

class ConstExp e where

Constant expressions

The default implementation is for Applicative interpretations.

Minimal complete definition

Nothing

Methods

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

Make a Dino literal from a Haskell value

lit :: Applicative e => a -> e a

Make a Dino literal from a Haskell value

Instances

ConstExp Maybe

Defined in Dino.Interpretation

Methods

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

ConstExp Identity

Defined in Dino.Interpretation

Methods

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

ConstExp DinoTypeRep

Defined in Dino.Interpretation

Methods

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

ConstExp Reified

Defined in Dino.Interpretation

Methods

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

ConstExp (Either e)

Defined in Dino.Interpretation

Methods

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

ConstExp e => ConstExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

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

ConstExp e => ConstExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

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

ConstExp e => ConstExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

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

Applicative e => ConstExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

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

ConstExp e => ConstExp (Intensional e)

Defined in Dino.Interpretation

Methods

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

Monoid e => ConstExp (Fold e)

Defined in Dino.Interpretation

Methods

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

Monad m => ConstExp (ExceptT e m)

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

ConstExp e => ConstExp (Exp e)

Defined in Dino.Expression

Methods

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

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

Defined in Dino.Interpretation

Methods

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

Applicative m => ConstExp (ReaderT env m)

Defined in Dino.Interpretation

Methods

lit :: DinoType a => a -> ReaderT env m a

true :: ConstExp e => e Bool

false :: ConstExp e => e Bool

text :: ConstExp e => Text -> e Text

Constant text expression

With OverloadedStrings enabled, text literals can be written simply as "...".

Numeric expressions

class NumExp e where

Numeric expressions

The default implementations are for Applicative interpretations.

Minimal complete definition

Nothing

Methods

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

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

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

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

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

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

Convert an integer to any numeric type

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

floor x returns the greatest integer not greater than x

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

truncate x returns the integer nearest x between zero and x

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

Round to the specified number of decimals

add :: (Applicative e, Num a) => e a -> e a -> e a

sub :: (Applicative e, Num a) => e a -> e a -> e a

mul :: (Applicative e, Num a) => e a -> e a -> e a

absE :: (Applicative e, Num a) => e a -> e a

signE :: (Applicative e, Num a) => e a -> e a

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

Convert an integer to any numeric type

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

floor x returns the greatest integer not greater than x

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

truncate x returns the integer nearest x between zero and x

roundN :: (Applicative e, RealFrac a) => Int -> e a -> e a

Round to the specified number of decimals

Instances

NumExp Maybe

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

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

NumExp (Either e)

Defined in Dino.Interpretation

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

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

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

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

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

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

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

Monad m => NumExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

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

NumExp e => NumExp (Exp e)

Defined in Dino.Expression

Methods

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

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

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

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

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

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

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

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

roundN :: RealFrac a => Int -> Exp e a -> Exp e 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

Applicative m => NumExp (ReaderT env m)

Defined in Dino.Interpretation

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

fromInt :: (NumExp e, DinoType a, Num a) => e Integer -> e a

Convert an Integer to any numeric type

class FracExp e where

Fractional expressions

The default implementation is for Applicative interpretations.

Minimal complete definition

Nothing

Methods

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

Division

fdiv :: (Applicative e, Fractional a) => e a -> e a -> e a

Division

Instances

FracExp Maybe

Defined in Dino.Interpretation

Methods

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

FracExp Identity

Defined in Dino.Interpretation

Methods

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

FracExp DinoTypeRep

Defined in Dino.Interpretation

Methods

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

FracExp Reified

Defined in Dino.Interpretation

Methods

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

FracExp (Either e)

Defined in Dino.Interpretation

Methods

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

FracExp e => FracExp (CollectAssertions e)

Defined in Dino.Interpretation

Methods

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

FracExp e => FracExp (AssertViaMonadThrow e)

Defined in Dino.Interpretation

Methods

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

FracExp e => FracExp (AssertViaMonadError e)

Defined in Dino.Interpretation

Methods

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

Applicative e => FracExp (EvalEnv e)

Defined in Dino.Interpretation

Methods

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

FracExp e => FracExp (Intensional e)

Defined in Dino.Interpretation

Methods

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

Monoid e => FracExp (Fold e)

Defined in Dino.Interpretation

Methods

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

Monad m => FracExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

Methods

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

FracExp e => FracExp (Exp e)

Defined in Dino.Expression

Methods

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

(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

Applicative m => FracExp (ReaderT env m)

Defined in Dino.Interpretation

Methods

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

(./) :: (ConstExp e, FracExp e, CompareExp e, CondExpFO e, DinoType a, Fractional a) => e a -> e a -> e a

Division that returns 0 when the denominator is 0

Logic expressions

class LogicExp e where

Logic expressions

The default implementations are for Applicative interpretations.

Minimal complete definition

Nothing

Methods

not :: e Bool -> e Bool

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

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

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

not :: Applicative e => e Bool -> e Bool

conj :: Applicative e => e Bool -> e Bool -> e Bool

disj :: Applicative e => e Bool -> e Bool -> e Bool

xor :: Applicative e => e Bool -> e Bool -> e Bool

Instances

LogicExp Maybe

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

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

LogicExp (Either e)

Defined in Dino.Interpretation

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

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

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

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

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

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

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

Monad m => LogicExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

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

LogicExp e => LogicExp (Exp e)

Defined in Dino.Expression

Methods

not :: Exp e Bool -> Exp e Bool

conj :: Exp e Bool -> Exp e Bool -> Exp e Bool

disj :: Exp e Bool -> Exp e Bool -> Exp e Bool

xor :: Exp e Bool -> Exp e Bool -> Exp e Bool

(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

Applicative m => LogicExp (ReaderT env m)

Defined in Dino.Interpretation

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

(&&) :: LogicExp e => e Bool -> e Bool -> e Bool infixr 3

(||) :: LogicExp e => e Bool -> e Bool -> e Bool infixr 2

Comparisons

class CompareExp e where

Comparisons

The default implementations are for Applicative interpretations.

Minimal complete definition

Nothing

Methods

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

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

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

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

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

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

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

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

eq :: (Applicative e, Eq a) => e a -> e a -> e Bool

neq :: (Applicative e, Eq a) => e a -> e a -> e Bool

lt :: (Applicative e, Ord a) => e a -> e a -> e Bool

gt :: (Applicative e, Ord a) => e a -> e a -> e Bool

lte :: (Applicative e, Ord a) => e a -> e a -> e Bool

gte :: (Applicative e, Ord a) => e a -> e a -> e Bool

min :: (Applicative e, Ord a) => e a -> e a -> e a

max :: (Applicative e, Ord a) => e a -> e a -> e a

Instances

CompareExp Maybe

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

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

CompareExp (Either e)

Defined in Dino.Interpretation

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

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

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

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

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

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

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

Monad m => CompareExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

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

CompareExp e => CompareExp (Exp e)

Defined in Dino.Expression

Methods

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

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

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

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

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

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

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

max :: Ord a => Exp e a -> Exp e a -> Exp e 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

Applicative m => CompareExp (ReaderT env m)

Defined in Dino.Interpretation

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

(==) :: (Eq a, CompareExp e) => e a -> e a -> e Bool infix 4

(/=) :: (Eq a, CompareExp e) => e a -> e a -> e Bool infix 4

(<) :: (Ord a, CompareExp e) => e a -> e a -> e Bool infix 4

(>) :: (Ord a, CompareExp e) => e a -> e a -> e Bool infix 4

(<=) :: (Ord a, CompareExp e) => e a -> e a -> e Bool infix 4

(>=) :: (Ord a, CompareExp e) => e a -> e a -> e Bool infix 4

(==!) :: (ConstExp e, CompareExp e, DinoType a) => e a -> a -> e Bool infix 4

Check equality against a constant value

Conditionals

data a :-> b infix 1

Representation of a case in cases

Constructors

a :-> b infix 1

Instances

Bifunctor (:->)

Defined in Dino.Expression

Methods

bimap :: (a -> b) -> (c -> d) -> (a :-> c) -> b :-> d

first :: (a -> b) -> (a :-> c) -> b :-> c

second :: (b -> c) -> (a :-> b) -> a :-> c

Functor ((:->) a)

Defined in Dino.Expression

Methods

fmap :: (a0 -> b) -> (a :-> a0) -> a :-> b

(<$) :: a0 -> (a :-> b) -> a :-> a0

Foldable ((:->) a)

Defined in Dino.Expression

Methods

fold :: Monoid m => (a :-> m) -> m

foldMap :: Monoid m => (a0 -> m) -> (a :-> a0) -> m

foldr :: (a0 -> b -> b) -> b -> (a :-> a0) -> b

foldr' :: (a0 -> b -> b) -> b -> (a :-> a0) -> b

foldl :: (b -> a0 -> b) -> b -> (a :-> a0) -> b

foldl' :: (b -> a0 -> b) -> b -> (a :-> a0) -> b

foldr1 :: (a0 -> a0 -> a0) -> (a :-> a0) -> a0

foldl1 :: (a0 -> a0 -> a0) -> (a :-> a0) -> a0

toList :: (a :-> a0) -> [a0]

null :: (a :-> a0) -> Bool

length :: (a :-> a0) -> Int

elem :: Eq a0 => a0 -> (a :-> a0) -> Bool

maximum :: Ord a0 => (a :-> a0) -> a0

minimum :: Ord a0 => (a :-> a0) -> a0

sum :: Num a0 => (a :-> a0) -> a0

product :: Num a0 => (a :-> a0) -> a0

Traversable ((:->) a)

Defined in Dino.Expression

Methods

traverse :: Applicative f => (a0 -> f b) -> (a :-> a0) -> f (a :-> b)

sequenceA :: Applicative f => (a :-> f a0) -> f (a :-> a0)

mapM :: Monad m => (a0 -> m b) -> (a :-> a0) -> m (a :-> b)

sequence :: Monad m => (a :-> m a0) -> m (a :-> a0)

(Eq a, Eq b) => Eq (a :-> b)

Defined in Dino.Expression

Methods

(==) :: (a :-> b) -> (a :-> b) -> Bool

(/=) :: (a :-> b) -> (a :-> b) -> Bool

(Show a, Show b) => Show (a :-> b)

Defined in Dino.Expression

Methods

showsPrec :: Int -> (a :-> b) -> ShowS

show :: (a :-> b) -> String

showList :: [a :-> b] -> ShowS

(-->) :: a -> b -> a :-> b infix 1

Construct a case in cases, match, etc.

Example:

beaufortScale :: _ => Exp e a -> Exp e Text
beaufortScale v = match v
  [ (< 0.5)   --> "calm"
  , (< 13.8)  --> "breeze"
  , (< 24.5)  --> "gale" ]
  ( Otherwise --> "storm" )

data Otherwise

Marker for the default case in cases

Constructors

Otherwise

class CondExpFO e where

Helper class to CondExp containing only first-order constructs

The reason for having this class is that there are types for which CondExpFO can be derived but CondExp cannot.

Minimal complete definition

Nothing

Methods

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

Construct an optional value that is present

cases

Arguments

:: [e Bool :-> e a]

Guarded expressions

-> (Otherwise :-> e a)

Fall-through case

-> e a

Case expression

partial_cases

Arguments

:: HasCallStack

=> [e Bool :-> e a]

Guarded expressions

-> e a

Case expression without fall-through

Evaluation may fail if the cases are not complete.

just :: Applicative e => e a -> e (Maybe a)

Construct an optional value that is present

cases

Arguments

:: Monad e

=> [e Bool :-> e a]

Guarded expressions

-> (Otherwise :-> e a)

Fall-through case

-> e a

Case expression

partial_cases

Arguments

:: (Monad e, HasCallStack)

=> [e Bool :-> e a]

Guarded expressions

-> e a

Case expression without fall-through

Evaluation may fail if the cases are not complete.

Instances

CondExpFO Maybe

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

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

CondExpFO (Either e)

Defined in Dino.Interpretation

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

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

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

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

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

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

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

Monad m => CondExpFO (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

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

CondExpFO e => CondExpFO (Exp e)

Defined in Dino.Expression

Methods

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

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

partial_cases :: HasCallStack => [Exp e Bool :-> Exp e a] -> Exp e 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

Monad m => CondExpFO (ReaderT env m)

Defined in Dino.Interpretation

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

class CondExpFO e => CondExp e where

Expressions supporting conditionals

The default implementations are for monadic interpretations.

Minimal complete definition

Nothing

Methods

maybe

Arguments

:: DinoType a

=> e b

Result when nothing

-> (e a -> e b)

Result when just

-> e (Maybe a)

Value to deconstruct

-> e b

Deconstruct an optional value

maybe

Arguments

:: Monad e

=> e b

Result when nothing

-> (e a -> e b)

Result when just

-> e (Maybe a)

Value to deconstruct

-> e b

Deconstruct an optional value

Instances

CondExp Maybe

Defined in Dino.Interpretation

Methods

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

CondExp Identity

Defined in Dino.Interpretation

Methods

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

CondExp DinoTypeRep

Defined in Dino.Interpretation

Methods

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

CondExp (Either e)

Defined in Dino.Interpretation

Methods

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

(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

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

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, 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

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

Monad m => CondExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

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

CondExp e => CondExp (Exp e)

Defined in Dino.Expression

Methods

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

Monad m => CondExp (ReaderT env m)

Defined in Dino.Interpretation

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

default_partial_cases :: (CondExpFO e, HasCallStack) => [e Bool :-> e a] -> e a

nothing :: (ConstExp e, DinoType a) => e (Maybe a)

Construct an optional value that is missing

isJust :: (ConstExp e, CondExp e, DinoType a) => e (Maybe a) -> e Bool

match

Arguments

:: CondExpFO e

=> a

Scrutinee

-> [(a -> e Bool) :-> e b]

Cases

-> (Otherwise :-> e b)

Fall-through case

-> e b

Case expression using Boolean functions for matching

matchConst

Arguments

:: (ConstExp e, CompareExp e, CondExpFO e, DinoType a)

=> e a

Scrutinee

-> [a :-> e b]

Cases

-> (Otherwise :-> e b)

Fall-through case

-> e b

Case expression matching a value against constants

Example:

operate c a = matchConst c
  [+ --> a + 1
  ,- --> a - 1
  ]
  (Otherwise --> a)

matchConstFull

Arguments

:: (ConstExp e, CompareExp e, CondExpFO e, DinoType a, Show a, Enum a, Bounded a, HasCallStack)

=> e a

Scrutinee

-> [a :-> e b]

Cases

-> e b

A Version of matchConst for enumerations where the cases cover the whole domain

An error is thrown if the cases do not cover the whole domain.

ifThenElse

Arguments

:: CondExpFO e

=> e Bool

Condition

-> e a

True branch

-> e a

False branch

-> e a

Conditional expression

Enable RebindableSyntax to use the standard syntax if a then b else c for calling this function.

fromMaybe :: (CondExp e, DinoType a) => e a -> e (Maybe a) -> e a

Lists

class ListExpFO e where

Helper class to ListExp containing only first-order constructs

The reason for having this class is that there are types for which ListExpFO can be derived but ListExp cannot.

Minimal complete definition

Nothing

Methods

range

Arguments

:: Enum a

=> e a

Lower bound (inclusive)

-> e a

Upper bound (inclusive)

-> e [a]

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

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

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

range

Arguments

:: (Applicative e, Enum a)

=> e a

Lower bound (inclusive)

-> e a

Upper bound (inclusive)

-> e [a]

list :: Applicative e => [e a] -> e [a]

headE :: Applicative e => e [a] -> e (Maybe a)

append :: Applicative e => e [a] -> e [a] -> e [a]

Instances

ListExpFO Maybe

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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]

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]

ListExpFO (Either e)

Defined in Dino.Interpretation

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]

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]

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]

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]

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]

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]

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]

Monad m => ListExpFO (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

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]

ListExpFO e => ListExpFO (Exp e)

Defined in Dino.Expression

Methods

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

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

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

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

(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]

Monad m => ListExpFO (ReaderT env m)

Defined in Dino.Interpretation

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]

class ListExpFO e => ListExp e where

Minimal complete definition

Nothing

Methods

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

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

foldE

Arguments

:: (DinoType a, DinoType b)

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

Reducer function

-> e a

Initial value

-> e [b]

List to reduce (traversed left-to-right)

-> e a

Left fold

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

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

foldE

Arguments

:: Monad e

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

Reducer function

-> e a

Initial value

-> e [b]

List to reduce (traversed left-to-right)

-> e a

Left fold

Instances

ListExp Maybe

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

ListExp (Either e)

Defined in Dino.Interpretation

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 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

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

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, 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

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

Monad m => ListExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

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

ListExp e => ListExp (Exp e)

Defined in Dino.Expression

Methods

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

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

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

Monad m => ListExp (ReaderT env m)

Defined in Dino.Interpretation

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

Tuples

class TupleExp e where

Minimal complete definition

Nothing

Methods

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

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

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

pair :: Applicative e => e a -> e b -> e (a, b)

fstE :: Applicative e => e (a, b) -> e a

sndE :: Applicative e => e (a, b) -> e b

Instances

TupleExp Maybe

Defined in Dino.Interpretation

Methods

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

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

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

TupleExp Identity

Defined in Dino.Interpretation

Methods

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

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

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

TupleExp DinoTypeRep

Defined in Dino.Interpretation

Methods

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

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

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

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

TupleExp (Either e)

Defined in Dino.Interpretation

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

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

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

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

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

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

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

Monad m => TupleExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

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

(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

Monad m => TupleExp (ReaderT env m)

Defined in Dino.Interpretation

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

Let bindings

class LetExp e where

Minimal complete definition

Nothing

Methods

letE

Arguments

:: DinoType a

=> Text

Variable base name

-> e a

Value to share

-> (e a -> e b)

Body

-> e b

Share a value in a calculation

The default implementation of letE implements call-by-value.

letE

Arguments

:: Monad e

=> Text

Variable base name

-> e a

Value to share

-> (e a -> e b)

Body

-> e b

Share a value in a calculation

The default implementation of letE implements call-by-value.

Instances

LetExp Maybe

Defined in Dino.Interpretation

Methods

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

LetExp Identity

Defined in Dino.Interpretation

Methods

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

LetExp DinoTypeRep

Defined in Dino.Interpretation

Methods

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

LetExp (Either e)

Defined in Dino.Interpretation

Methods

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

(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

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

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

(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

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

Monad m => LetExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

Methods

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

LetExp e => LetExp (Exp e)

Defined in Dino.Expression

Methods

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

Monad m => LetExp (ReaderT env m)

Defined in Dino.Interpretation

Methods

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

share

Arguments

:: (LetExp e, DinoType a)

=> e a

Value to share

-> (e a -> e b)

Body

-> e b

Share a value in a calculation

Like letE but with the variable base name fixed to "share".

shared

Arguments

:: (LetExp e, DinoType a)

=> (e a -> e b)

Body

-> e a

Value to share

-> e b

Make a function with a shared argument

shared = flip share

Like letE but with the variable base name fixed to "share".

Records

data Field (f :: Symbol)

Constructors

Field

Instances

f1 ~ f2 => IsLabel f1 (Field f2)

Defined in Dino.Expression

Methods

fromLabel :: Field f2

class FieldExp e where

Minimal complete definition

Nothing

Methods

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

getField :: forall proxy f r a. (Applicative e, KnownSymbol f, HasField f r a) => proxy f -> e r -> e a

Instances

FieldExp Maybe

Defined in Dino.Interpretation

Methods

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

FieldExp Identity

Defined in Dino.Interpretation

Methods

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

FieldExp DinoTypeRep

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> DinoTypeRep r -> DinoTypeRep 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

FieldExp (Either e)

Defined in Dino.Interpretation

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> Either e r -> Either 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

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

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

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

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

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

Monad m => FieldExp (ExceptT e m)

Defined in Dino.Interpretation

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)

Defined in Dino.Interpretation

Methods

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

FieldExp e => FieldExp (Exp e)

Defined in Dino.Expression

Methods

getField :: (KnownSymbol f, HasField f r a, DinoType a) => proxy f -> Exp e r -> Exp e 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

Monad m => FieldExp (ReaderT env m)

Defined in Dino.Interpretation

Methods

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

field :: (FieldExp e, KnownSymbol f, HasField f r a, DinoType a) => Field f -> e r -> e a

Extract a field from a record

Use as follows (with OverloadedLabels):

field #name $ field #driver car

(<.) :: (FieldExp e, KnownSymbol f, HasField f r a, DinoType a) => Field f -> e r -> e a infixr 9

Extract a field from a record

Use as follows (with OverloadedLabels):

#name <. #driver <. car

Annotations

class AnnExp ann e where

Minimal complete definition

Nothing

Methods

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

Annotate an expression

Instances

AnnExp ann e => AnnExp ann (Exp e :: k -> Type)

Defined in Dino.Expression

Methods

ann :: ann -> Exp e a -> Exp e a

AnnExp ann Maybe

Defined in Dino.Interpretation

Methods

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

AnnExp ann Identity

Defined in Dino.Interpretation

Methods

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

AnnExp ann DinoTypeRep

Defined in Dino.Interpretation

Methods

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

AnnExp Text Reified

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

(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

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

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

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

Defined in Dino.Interpretation

Methods

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

Assertions

class AssertExp e where

Minimal complete definition

Nothing

Methods

assert

Arguments

:: Text

Assertion label

-> e Bool

Condition that should be true

-> e a

Expression to attach the assertion to

-> e a

Assert that a condition is true

Interpretations can choose whether to ignore the assertion or to check its validity. The default implementation ignores the assertion.

The following must hold for any monadic interpretation:

assert lab c a
  ==
(assert lab c (return ()) >> return a)

assertEq

Arguments

:: (Eq a, Show a)

=> Text

Assertion label

-> e a

Reference expression

-> e a

Actual expression

-> e a

Assert that an expression is semantically equivalent to a reference expression

Interpretations can choose whether to ignore the assertion or to check its validity. The default implementation ignores the assertion.

The following must hold for any monadic interpretation:

assertEq lab ref act
  ==
( do a <- act
     assertEq lab ref (return a)
     return a
)

Instances

AssertExp Maybe

Ignoring assertion for efficiency

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

Methods

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

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

AssertExp DinoTypeRep

Defined in Dino.Interpretation

Methods

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

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

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

AssertExp (Either e)

Ignoring assertion for efficiency

Defined in Dino.Interpretation

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

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

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

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

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

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

AssertExp (ExceptT e m)

Ignoring assertion for efficiency

Defined in Dino.Interpretation

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

Defined in Dino.Interpretation

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

AssertExp e => AssertExp (Exp e)

Defined in Dino.Expression

Methods

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

assertEq :: (Eq a, Show a) => Text -> Exp e a -> Exp e a -> Exp e 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

AssertExp (ReaderT env m)

Ignoring assertion for efficiency

Defined in Dino.Interpretation

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

Concrete expression wrapper

newtype Exp e a

Useful wrapper to get a concrete type for tagless DSL expressions

The problem solved by this type can be explained as follows:

Suppose you write a numeric expression with the most general type:

myExp1 :: Num e => e
myExp1 = 1+2

And suppose you define an evaluation function as follows:

eval1 :: (forall e . (ConstExp e, NumExp e) => e a) -> a
eval1 = runIdentity

The problem is that we cannot pass myExp1 to eval1:

test1 :: Int
test1 = eval1 myExp1

This leads to:

• Could not deduce (Num (e Int)) ...

And we don't want to change eval1 to

eval1 :: (forall e . (ConstExp e, NumExp e, Num (e a)) => e a) -> a

since this requires the expression to return a number (and not e.g. a Boolean), and it also doesn't help to satisfy any internal numeric expressions that may use a different type than a.

Instead, the solution is to use Exp as follows:

myExp2 :: (ConstExp e, NumExp e, Num a) => Exp e a
myExp2 = 1+2

eval2 :: (forall e . (ConstExp e, NumExp e) => Exp e a) -> a
eval2 = runIdentity . unExp

test2 :: Int
test2 = eval2 myExp2

The trick is that there exists an instance

instance (Num a, ConstExp e, NumExp e) => Num (Exp e a)

So it is enough for eval2 to supply constraints on e, and it will automatically imply the availability of the Num instance.

Constructors

Exp

Fields

• unExp :: e a

Instances

AnnExp ann e => AnnExp ann (Exp e :: k -> Type)

Defined in Dino.Expression

Methods

ann :: ann -> Exp e a -> Exp e a

(FieldExp e1, e1 ~ e2, KnownSymbol f, HasField f r a, DinoType a) => IsLabel f (Exp e1 r -> Exp e2 a)

Defined in Dino.Expression

Methods

fromLabel :: Exp e1 r -> Exp e2 a

Monad e => Monad (Exp e)

Defined in Dino.Expression

Methods

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

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

return :: a -> Exp e a

fail :: String -> Exp e a

Functor e => Functor (Exp e)

Defined in Dino.Expression

Methods

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

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

Applicative e => Applicative (Exp e)

Defined in Dino.Expression

Methods

pure :: a -> Exp e a

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

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

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

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

AssertExp e => AssertExp (Exp e)

Defined in Dino.Expression

Methods

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

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

FieldExp e => FieldExp (Exp e)

Defined in Dino.Expression

Methods

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

LetExp e => LetExp (Exp e)

Defined in Dino.Expression

Methods

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

ListExp e => ListExp (Exp e)

Defined in Dino.Expression

Methods

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

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

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

ListExpFO e => ListExpFO (Exp e)

Defined in Dino.Expression

Methods

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

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

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

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

CondExp e => CondExp (Exp e)

Defined in Dino.Expression

Methods

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

CondExpFO e => CondExpFO (Exp e)

Defined in Dino.Expression

Methods

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

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

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

CompareExp e => CompareExp (Exp e)

Defined in Dino.Expression

Methods

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

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

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

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

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

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

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

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

LogicExp e => LogicExp (Exp e)

Defined in Dino.Expression

Methods

not :: Exp e Bool -> Exp e Bool

conj :: Exp e Bool -> Exp e Bool -> Exp e Bool

disj :: Exp e Bool -> Exp e Bool -> Exp e Bool

xor :: Exp e Bool -> Exp e Bool -> Exp e Bool

FracExp e => FracExp (Exp e)

Defined in Dino.Expression

Methods

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

NumExp e => NumExp (Exp e)

Defined in Dino.Expression

Methods

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

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

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

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

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

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

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

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

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

ConstExp e => ConstExp (Exp e)

Defined in Dino.Expression

Methods

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

Eq (e a) => Eq (Exp e a)

Defined in Dino.Expression

Methods

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

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

(ConstExp e, NumExp e, FracExp e, DinoType a, Fractional a) => Fractional (Exp e a)

Defined in Dino.Expression

Methods

(/) :: Exp e a -> Exp e a -> Exp e a

recip :: Exp e a -> Exp e a

fromRational :: Rational -> Exp e a

(ConstExp e, NumExp e, DinoType a, Num a) => Num (Exp e a)

Defined in Dino.Expression

Methods

(+) :: Exp e a -> Exp e a -> Exp e a

(-) :: Exp e a -> Exp e a -> Exp e a

(*) :: Exp e a -> Exp e a -> Exp e a

negate :: Exp e a -> Exp e a

abs :: Exp e a -> Exp e a

signum :: Exp e a -> Exp e a

fromInteger :: Integer -> Exp e a

Show (e a) => Show (Exp e a)

Defined in Dino.Expression

Methods

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

show :: Exp e a -> String

showList :: [Exp e a] -> ShowS

(ConstExp e, IsString a, DinoType a) => IsString (Exp e a)

Defined in Dino.Expression

Methods

fromString :: String -> Exp e a

Derived operations

Operations on Dino lists

sumE :: (ConstExp e, NumExp e, ListExp e, DinoType a, Num a) => e [a] -> e a

andE :: (ConstExp e, LogicExp e, ListExp e) => e [Bool] -> e Bool

orE :: (ConstExp e, LogicExp e, ListExp e) => e [Bool] -> e Bool

allE :: (ConstExp e, LogicExp e, ListExp e, DinoType a) => (e a -> e Bool) -> e [a] -> e Bool

anyE :: (ConstExp e, LogicExp e, ListExp e, DinoType a) => (e a -> e Bool) -> e [a] -> e Bool

find :: (LogicExp e, ListExp e, DinoType a) => (e a -> e Bool) -> e [a] -> e (Maybe a)

(<++>) :: ListExpFO e => e [a] -> e [a] -> e [a]

Operations on Haskell lists

and :: (ConstExp e, LogicExp e) => [e Bool] -> e Bool

or :: (ConstExp e, LogicExp e) => [e Bool] -> e Bool

all :: (ConstExp e, LogicExp e) => (a -> e Bool) -> [a] -> e Bool

any :: (ConstExp e, LogicExp e) => (a -> e Bool) -> [a] -> e Bool

Optional monad

data Optional e a where

Optional expressions with a Monad instance

Optional is handy to avoid nested uses of maybe. As an example, here is a safe division function:

safeDiv :: _ => e a -> e a -> Optional e (e a)
safeDiv a b = suppose $
  if (b /= lit 0)
    then just (fdiv a b)
    else nothing

And here is a calculation that defaults to 0 if any of the divisions fails:

foo :: _ => Exp e Double -> Exp e Double -> Exp e Double
foo a b = fromOptional 0 $ do
  x <- safeDiv a b
  y <- safeDiv b x
  safeDiv x y

Constructors

Return :: a -> Optional e a

Bind :: DinoType a => e (Maybe a) -> (e a -> Optional e b) -> Optional e b

Instances

Monad (Optional e)

Defined in Dino.Expression

Methods

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

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

return :: a -> Optional e a

fail :: String -> Optional e a

Functor (Optional e)

Defined in Dino.Expression

Methods

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

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

Applicative (Optional e)

Defined in Dino.Expression

Methods

pure :: a -> Optional e a

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

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

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

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

suppose :: DinoType a => e (Maybe a) -> Optional e (e a)

Lift an optional expression to Optional

optional

Arguments

:: (ConstExp e, CondExp e, LetExp e, DinoType a, DinoType b)

=> e b

Result if missing

-> (e a -> e b)

Result if present

-> Optional e (e a)

Value to examine

-> e b

Convert from Optional value to an optional expression

runOptional :: (ConstExp e, CondExp e, LetExp e, DinoType a) => Optional e (e a) -> e (Maybe a)

fromOptional

Arguments

:: (ConstExp e, CondExp e, LetExp e, DinoType a)

=> e a

Default value (in case the Optional value is missing)

-> Optional e (e a)

-> e a

Extract an Optional value