Data.Type.Disjunction

Two type combinators for working with disjunctions: A branch combinator '(:|:)', and a choice combinator '(:+:)'.

These are analogous to '(|||)' and '(+++)' from Arrow, respectively.

Documentation

data f :|: g :: k -> * where infixr 4

Constructors

L :: !(f a) -> (f :|: g) a

R :: !(g a) -> (f :|: g) a

Instances

Bifunctor1 m m m ((:|:) m)

Methods

bimap1 :: (forall a. f a -> h a) -> (forall a. g a -> i a) -> t f g b -> t h i b

Traversable1 l l ((:|:) l f)

Methods

traverse1 :: Applicative h => (forall a. f a -> h (g a)) -> t f b -> h (t g b)

Foldable1 l l ((:|:) l f)

Methods

foldMap1 :: Monoid m => (forall a. f a -> m) -> t f b -> m

Functor1 l l ((:|:) l f)

Methods

map1 :: (forall a. f a -> g a) -> t f b -> t g b

(Witness p q (f a), Witness p q (g a)) => Witness p q ((:|:) k f g a)

Associated Types

type WitnessC (p :: Constraint) (q :: Constraint) ((:|:) k f g a) :: Constraint

Methods

(\\) :: p => (q -> r) -> (k :|: f) g a -> r

(Read1 k f, Read1 k g) => Read1 k ((:|:) k f g)

Methods

readsPrec1 :: Int -> ReadS (Some ((k :|: f) g) f)

(Show1 k f, Show1 k g) => Show1 k ((:|:) k f g)

Methods

showsPrec1 :: Int -> f a -> ShowS

show1 :: f a -> String

(Ord1 k f, Ord1 k g) => Ord1 k ((:|:) k f g)

Methods

compare1 :: f a -> f a -> Ordering

(<#) :: f a -> f a -> Bool

(>#) :: f a -> f a -> Bool

(<=#) :: f a -> f a -> Bool

(>=#) :: f a -> f a -> Bool

(Eq1 k f, Eq1 k g) => Eq1 k ((:|:) k f g)

Methods

eq1 :: f a -> f a -> Bool

neq1 :: f a -> f a -> Bool

(Eq (f a), Eq (g a)) => Eq ((:|:) k f g a)

Methods

(==) :: (k :|: f) g a -> (k :|: f) g a -> Bool

(/=) :: (k :|: f) g a -> (k :|: f) g a -> Bool

(Ord (f a), Ord (g a)) => Ord ((:|:) k f g a)

Methods

compare :: (k :|: f) g a -> (k :|: f) g a -> Ordering

(<) :: (k :|: f) g a -> (k :|: f) g a -> Bool

(<=) :: (k :|: f) g a -> (k :|: f) g a -> Bool

(>) :: (k :|: f) g a -> (k :|: f) g a -> Bool

(>=) :: (k :|: f) g a -> (k :|: f) g a -> Bool

max :: (k :|: f) g a -> (k :|: f) g a -> (k :|: f) g a

min :: (k :|: f) g a -> (k :|: f) g a -> (k :|: f) g a

(Read (f a), Read (g a)) => Read ((:|:) k f g a)

Methods

readsPrec :: Int -> ReadS ((k :|: f) g a)

readList :: ReadS [(k :|: f) g a]

readPrec :: ReadPrec ((k :|: f) g a)

readListPrec :: ReadPrec [(k :|: f) g a]

(Show (f a), Show (g a)) => Show ((:|:) k f g a)

Methods

showsPrec :: Int -> (k :|: f) g a -> ShowS

show :: (k :|: f) g a -> String

showList :: [(k :|: f) g a] -> ShowS

type WitnessC p q ((:|:) k f g a)

type WitnessC p q ((:|:) k f g a) = (Witness p q (f a), Witness p q (g a))

(>|<) :: (f a -> r) -> (g a -> r) -> (f :|: g) a -> r infixr 2

data f :+: g :: Either k l -> * where infixr 4

Constructors

L' :: !(f a) -> (f :+: g) (Left a)

R' :: !(g b) -> (f :+: g) (Right b)

Instances

Witness p q (g b1) => Witness p q ((:+:) b k f g (Right k b b1))

Associated Types

type WitnessC (p :: Constraint) (q :: Constraint) ((:+:) b k f g (Right k b b1)) :: Constraint

Methods

(\\) :: p => (q -> r) -> (b :+: k) f g (Right k b b1) -> r

Witness p q (f a1) => Witness p q ((:+:) l a f g (Left a l a1))

Associated Types

type WitnessC (p :: Constraint) (q :: Constraint) ((:+:) l a f g (Left a l a1)) :: Constraint

Methods

(\\) :: p => (q -> r) -> (l :+: a) f g (Left a l a1) -> r

Bifunctor1 (Either k l) l k ((:+:) l k)

Methods

bimap1 :: (forall a. f a -> h a) -> (forall a. g a -> i a) -> t f g b -> t h i b

Traversable1 (Either k1 k) k ((:+:) k k1 f)

Methods

traverse1 :: Applicative h => (forall a. f a -> h (g a)) -> t f b -> h (t g b)

Foldable1 (Either k1 k) k ((:+:) k k1 f)

Methods

foldMap1 :: Monoid m => (forall a. f a -> m) -> t f b -> m

Functor1 (Either k1 k) k ((:+:) k k1 f)

Methods

map1 :: (forall a. f a -> g a) -> t f b -> t g b

(Read1 k f, Read1 l g) => Read1 (Either k l) ((:+:) l k f g)

Methods

readsPrec1 :: Int -> ReadS (Some ((l :+: k) f g) f)

(Show1 k f, Show1 l g) => Show1 (Either k l) ((:+:) l k f g)

Methods

showsPrec1 :: Int -> f a -> ShowS

show1 :: f a -> String

(Ord1 k f, Ord1 l g) => Ord1 (Either k l) ((:+:) l k f g)

Methods

compare1 :: f a -> f a -> Ordering

(<#) :: f a -> f a -> Bool

(>#) :: f a -> f a -> Bool

(<=#) :: f a -> f a -> Bool

(>=#) :: f a -> f a -> Bool

(Eq1 k f, Eq1 l g) => Eq1 (Either k l) ((:+:) l k f g)

Methods

eq1 :: f a -> f a -> Bool

neq1 :: f a -> f a -> Bool

Known b g b1 => Known (Either k b) ((:+:) b k f g) (Right k b b1)

Associated Types

type KnownC ((:+:) b k f g) (Right k b b1 :: (:+:) b k f g -> *) (a :: (:+:) b k f g) :: Constraint

Methods

known :: Right k b b1 a

Known a f a1 => Known (Either a l) ((:+:) l a f g) (Left a l a1)

Associated Types

type KnownC ((:+:) l a f g) (Left a l a1 :: (:+:) l a f g -> *) (a :: (:+:) l a f g) :: Constraint

Methods

known :: Left a l a1 a

(Eq (f (FromLeft k l e)), Eq (g (FromRight k l e))) => Eq ((:+:) l k f g e)

Methods

(==) :: (l :+: k) f g e -> (l :+: k) f g e -> Bool

(/=) :: (l :+: k) f g e -> (l :+: k) f g e -> Bool

(Ord (f (FromLeft k l e)), Ord (g (FromRight k l e))) => Ord ((:+:) l k f g e)

Methods

compare :: (l :+: k) f g e -> (l :+: k) f g e -> Ordering

(<) :: (l :+: k) f g e -> (l :+: k) f g e -> Bool

(<=) :: (l :+: k) f g e -> (l :+: k) f g e -> Bool

(>) :: (l :+: k) f g e -> (l :+: k) f g e -> Bool

(>=) :: (l :+: k) f g e -> (l :+: k) f g e -> Bool

max :: (l :+: k) f g e -> (l :+: k) f g e -> (l :+: k) f g e

min :: (l :+: k) f g e -> (l :+: k) f g e -> (l :+: k) f g e

(Show (f (FromLeft k l e)), Show (g (FromRight k l e))) => Show ((:+:) l k f g e)

Methods

showsPrec :: Int -> (l :+: k) f g e -> ShowS

show :: (l :+: k) f g e -> String

showList :: [(l :+: k) f g e] -> ShowS

type WitnessC p q ((:+:) b k f g (Right k b b1))

type WitnessC p q ((:+:) b k f g (Right k b b1)) = Witness p q (g b1)

type WitnessC p q ((:+:) l a f g (Left a l a1))

type WitnessC p q ((:+:) l a f g (Left a l a1)) = Witness p q (f a1)

type KnownC (Either k b) ((:+:) b k f g) (Right k b b1)

type KnownC (Either k b) ((:+:) b k f g) (Right k b b1) = Known b g b1

type KnownC (Either a l) ((:+:) l a f g) (Left a l a1)

type KnownC (Either a l) ((:+:) l a f g) (Left a l a1) = Known a f a1

(>+<) :: (forall a. e ~ Left a => f a -> r) -> (forall b. e ~ Right b => g b -> r) -> (f :+: g) e -> r infixr 2