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 k1 k2 f, IShow k1 k2 g) => IShow k1 k2 ((:+:) (k1 -> *) k2 f g)

Methods

ishow :: f (Const (((k1 -> *) :+: k2) f g) String) i -> Const k 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)

(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

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

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

Methods

imap :: (forall (i' :: ((i -> *) :+: i) f g). a i' -> b i') -> forall (i' :: ((i -> *) :+: i) f g). 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' :: ((i -> *) :+: i) f g). a i' -> f (b i')) -> forall (i' :: ((i -> *) :+: i) f g). 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 -> k2 -> *) f h, Parseable (k1 -> k2 -> *) g h) => Parseable (k1 -> k2 -> *) ((:+:) k1 k2 f g) h

Methods

parser :: Proxy ((k1 :+: k2) 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.