Data.Expression.Utils.Indexed.Sum

Documentation

data (f :+: g) a i infixr 8

Sum of two indexed functors

Constructors

InL (f a i)

InR (g a i)

Instances

(IShow k k1 f, IShow k k1 g) => IShow k k1 ((:+:) k (k1 -> *) f g)

Methods

ishow :: f (Const k String) i -> Const ((k :+: (k1 -> *)) f g) String i

(IFunctor k f, IFunctor k g, IFunctor k h, (:<:) k f g) => (:<:) k f ((:+:) k (k -> *) h g)

Methods

inj :: (k :+: (k -> *)) h g a i -> g a i

prj :: g a i -> Maybe ((k :+: (k -> *)) h g a i)

(IFunctor k f, IFunctor k g) => (:<:) k f ((:+:) k (k -> *) f g)

Methods

inj :: (k :+: (k -> *)) f g a i -> g a i

prj :: g a i -> Maybe ((k :+: (k -> *)) f g a i)

(IFoldable i f, IFoldable i g) => IFoldable i ((:+:) i (i -> *) f g)

Methods

ifold :: Monoid m => f (Const ((i :+: (i -> *)) f g) m) i' -> Const ((i :+: (i -> *)) f g) m i'

(IEq1 i f, IEq1 i g) => IEq1 i ((:+:) i (i -> *) f g)

Methods

ieq1 :: IEq ((i :+: (i -> *)) f g) a => f a j -> f a j -> Bool

(IFunctor i f, IFunctor i g) => IFunctor i ((:+:) i (i -> *) f g)

Methods

imap :: (forall i'. a i' -> b i') -> forall i'. f a i' -> f b i'

index :: f a i' -> Sing ((i :+: (i -> *)) f g) i'

(ITraversable i f, ITraversable i g) => ITraversable i ((:+:) i (i -> *) f g)

Methods

itraverse :: Applicative f => (forall i'. a i' -> f (b i')) -> forall i'. t a i' -> f (t b i')

(MaybeQuantified k f, MaybeQuantified k g) => MaybeQuantified k ((:+:) k (k -> *) f g)

Methods

isQuantified' :: MaybeQuantified ((k :+: (k -> *)) f g) g => f (IFix ((k :+: (k -> *)) f g) g) s -> Const ((k :+: (k -> *)) f g) Any s

freevars' :: f (Const ((k :+: (k -> *)) f g) [DynamicallySorted (VarF (Sort -> *))]) s -> Const ((k :+: (k -> *)) f g) [DynamicallySorted (VarF (Sort -> *))] s

JoinSemiLattice (ALia BooleanSort)

Methods

(\/) :: ALia BooleanSort -> ALia BooleanSort -> ALia BooleanSort

join :: ALia BooleanSort -> ALia BooleanSort -> ALia BooleanSort

JoinSemiLattice (QFALia BooleanSort)

Methods

(\/) :: QFALia BooleanSort -> QFALia BooleanSort -> QFALia BooleanSort

join :: QFALia BooleanSort -> QFALia BooleanSort -> QFALia BooleanSort

JoinSemiLattice (Lia BooleanSort)

Methods

(\/) :: Lia BooleanSort -> Lia BooleanSort -> Lia BooleanSort

join :: Lia BooleanSort -> Lia BooleanSort -> Lia BooleanSort

JoinSemiLattice (QFLia BooleanSort)

Methods

(\/) :: QFLia BooleanSort -> QFLia BooleanSort -> QFLia BooleanSort

join :: QFLia BooleanSort -> QFLia BooleanSort -> QFLia BooleanSort

JoinSemiLattice (QFLogic BooleanSort)

Methods

(\/) :: QFLogic BooleanSort -> QFLogic BooleanSort -> QFLogic BooleanSort

join :: QFLogic BooleanSort -> QFLogic BooleanSort -> QFLogic BooleanSort

MeetSemiLattice (ALia BooleanSort)

Methods

(/\) :: ALia BooleanSort -> ALia BooleanSort -> ALia BooleanSort

meet :: ALia BooleanSort -> ALia BooleanSort -> ALia BooleanSort

MeetSemiLattice (QFALia BooleanSort)

Methods

(/\) :: QFALia BooleanSort -> QFALia BooleanSort -> QFALia BooleanSort

meet :: QFALia BooleanSort -> QFALia BooleanSort -> QFALia BooleanSort

MeetSemiLattice (Lia BooleanSort)

Methods

(/\) :: Lia BooleanSort -> Lia BooleanSort -> Lia BooleanSort

meet :: Lia BooleanSort -> Lia BooleanSort -> Lia BooleanSort

MeetSemiLattice (QFLia BooleanSort)

Methods

(/\) :: QFLia BooleanSort -> QFLia BooleanSort -> QFLia BooleanSort

meet :: QFLia BooleanSort -> QFLia BooleanSort -> QFLia BooleanSort

MeetSemiLattice (QFLogic BooleanSort)

Methods

(/\) :: QFLogic BooleanSort -> QFLogic BooleanSort -> QFLogic BooleanSort

meet :: QFLogic BooleanSort -> QFLogic BooleanSort -> QFLogic BooleanSort

Lattice (ALia BooleanSort)

Lattice (QFALia BooleanSort)

Lattice (Lia BooleanSort)

Lattice (QFLia BooleanSort)

Lattice (QFLogic BooleanSort)

BoundedJoinSemiLattice (ALia BooleanSort)

Methods

bottom :: ALia BooleanSort

BoundedJoinSemiLattice (QFALia BooleanSort)

Methods

bottom :: QFALia BooleanSort

BoundedJoinSemiLattice (Lia BooleanSort)

Methods

bottom :: Lia BooleanSort

BoundedJoinSemiLattice (QFLia BooleanSort)

Methods

bottom :: QFLia BooleanSort

BoundedJoinSemiLattice (QFLogic BooleanSort)

Methods

bottom :: QFLogic BooleanSort

BoundedMeetSemiLattice (ALia BooleanSort)

Methods

top :: ALia BooleanSort

BoundedMeetSemiLattice (QFALia BooleanSort)

Methods

top :: QFALia BooleanSort

BoundedMeetSemiLattice (Lia BooleanSort)

Methods

top :: Lia BooleanSort

BoundedMeetSemiLattice (QFLia BooleanSort)

Methods

top :: QFLia BooleanSort

BoundedMeetSemiLattice (QFLogic BooleanSort)

Methods

top :: QFLogic BooleanSort

BoundedLattice (ALia BooleanSort)

BoundedLattice (QFALia BooleanSort)

BoundedLattice (Lia BooleanSort)

BoundedLattice (QFLia BooleanSort)

BoundedLattice (QFLogic BooleanSort)

ComplementedLattice (ALia BooleanSort)

Methods

complement :: ALia BooleanSort -> ALia BooleanSort

ComplementedLattice (QFALia BooleanSort)

Methods

complement :: QFALia BooleanSort -> QFALia BooleanSort

ComplementedLattice (Lia BooleanSort)

Methods

complement :: Lia BooleanSort -> Lia BooleanSort

ComplementedLattice (QFLia BooleanSort)

Methods

complement :: QFLia BooleanSort -> QFLia BooleanSort

ComplementedLattice (QFLogic BooleanSort)

Methods

complement :: QFLogic BooleanSort -> QFLogic BooleanSort

(Parseable (k1 -> k -> *) f h, Parseable (k1 -> k -> *) g h) => Parseable (k1 -> k -> *) ((:+:) k k1 f g) h

Methods

parser :: Proxy ((k :+: k1) f g) h -> Parser (DynamicallySorted g) -> Parser (DynamicallySorted g)

class (IFunctor f, IFunctor g) => f :<: g where

Inclusion relation for indexed sum functors

Minimal complete definition

inj, prj

Methods

inj :: f a i -> g a i

prj :: g a i -> Maybe (f a i)

Instances

IFunctor i f => (:<:) i f f

Methods

inj :: f a i -> g a i

prj :: g a i -> Maybe (f a i)

(IFunctor k f, IFunctor k g, IFunctor k h, (:<:) k f g) => (:<:) k f ((:+:) k (k -> *) h g)

Methods

inj :: (k :+: (k -> *)) h g a i -> g a i

prj :: g a i -> Maybe ((k :+: (k -> *)) h g a i)

(IFunctor k f, IFunctor k g) => (:<:) k f ((:+:) k (k -> *) f g)

Methods

inj :: (k :+: (k -> *)) f g a i -> g a i

prj :: g a i -> Maybe ((k :+: (k -> *)) f g a i)

inject :: g :<: f => forall i. g (IFix f) i -> IFix f i

Inject a component into a sum.

match :: g :<: f => forall i. IFix f i -> Maybe (g (IFix f) i)

Try to unpack a sum into a component.