Safe Haskell	None
Language	Haskell2010

Data.Union

Description

Extensible type-safe unions.

Synopsis

Documentation

data Union (f :: u -> *) (as :: [u]) where #

A union is parameterized by a universe u, an interpretation f and a list of labels as. The labels of the union are given by inhabitants of the kind u; the type of values at any label a :: u is given by its interpretation f a :: *.

Constructors

This :: !(f a) -> Union f (a ': as)
That :: !(Union f as) -> Union f (a ': as)

Instances

(Eq (f a2), Eq (Union a1 f as)) => Eq (Union a1 f ((:) a1 a2 as)) #
Methods (==) :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Bool # (/=) :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Bool #
Eq (Union u f ([] u)) #
Methods (==) :: Union u f [u] -> Union u f [u] -> Bool # (/=) :: Union u f [u] -> Union u f [u] -> Bool #
(Ord (f a2), Ord (Union a1 f as)) => Ord (Union a1 f ((:) a1 a2 as)) #
Methods compare :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Ordering # (<) :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Bool # (<=) :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Bool # (>) :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Bool # (>=) :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Bool # max :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) # min :: Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) -> Union a1 f ((a1 ': a2) as) #
Ord (Union u f ([] u)) #
Methods compare :: Union u f [u] -> Union u f [u] -> Ordering # (<) :: Union u f [u] -> Union u f [u] -> Bool # (<=) :: Union u f [u] -> Union u f [u] -> Bool # (>) :: Union u f [u] -> Union u f [u] -> Bool # (>=) :: Union u f [u] -> Union u f [u] -> Bool # max :: Union u f [u] -> Union u f [u] -> Union u f [u] # min :: Union u f [u] -> Union u f [u] -> Union u f [u] #
(Show (f a2), Show (Union a1 f as)) => Show (Union a1 f ((:) a1 a2 as)) #
Methods showsPrec :: Int -> Union a1 f ((a1 ': a2) as) -> ShowS # show :: Union a1 f ((a1 ': a2) as) -> String # showList :: [Union a1 f ((a1 ': a2) as)] -> ShowS #
Show (Union u f ([] u)) #
Methods showsPrec :: Int -> Union u f [u] -> ShowS # show :: Union u f [u] -> String # showList :: [Union u f [u]] -> ShowS #
((~) (* -> ) f Identity, Exception a, Typeable [] as, Exception (Union * f as)) => Exception (Union * f ((:) * a as)) #
Methods toException :: Union * f ((* ': a) as) -> SomeException # fromException :: SomeException -> Maybe (Union * f ((* ': a) as)) # displayException :: Union * f ((* ': a) as) -> String #
(~) (* -> ) f Identity => Exception (Union f ([] *)) #
Methods toException :: Union * f [] -> SomeException # fromException :: SomeException -> Maybe (Union f []) # displayException :: Union f [*] -> String #
(NFData (f a2), NFData (Union a1 f as)) => NFData (Union a1 f ((:) a1 a2 as)) #
Methods rnf :: Union a1 f ((a1 ': a2) as) -> () #
NFData (Union u f ([] u)) #
Methods rnf :: Union u f [u] -> () #

union :: (Union f as -> c) -> (f a -> c) -> Union f (a ': as) -> c #

Case analysis for unions.

absurdUnion :: Union f '[] -> a #

Since a union with an empty list of labels is uninhabited, we can recover any type from it.

umap :: (forall a. f a -> g a) -> Union f as -> Union g as #

_This :: Prism (Union f (a ': as)) (Union f (b ': as)) (f a) (f b) #

_That :: Prism (Union f (a ': as)) (Union f (a ': bs)) (Union f as) (Union f bs) #

class i ~ RIndex a as => UElem (a :: u) (as :: [u]) (i :: Nat) where #

Minimal complete definition

uprism | ulift, umatch

Methods

uprism :: Prism' (Union f as) (f a) #

ulift :: f a -> Union f as #

umatch :: Union f as -> Maybe (f a) #

Instances

UElem a1 a2 ((:) a1 a2 as) Z #
Methods uprism :: (Choice p, Applicative f) => p (f ((a1 ': a2) as)) (f (f ((a1 ': a2) as))) -> p (Union a2 f Z) (f (Union a2 f Z)) # ulift :: f ((a1 ': a2) as) -> Union a2 f Z # umatch :: Union a2 f Z -> Maybe (f ((a1 ': a2) as)) #
((~) Nat (RIndex a1 a2 ((:) a1 b as)) (S i), UElem a1 a2 as i) => UElem a1 a2 ((:) a1 b as) (S i) #
Methods uprism :: (Choice p, Applicative f) => p (f ((a1 ': b) as)) (f (f ((a1 ': b) as))) -> p (Union a2 f (S i)) (f (Union a2 f (S i))) # ulift :: f ((a1 ': b) as) -> Union a2 f (S i) # umatch :: Union a2 f (S i) -> Maybe (f ((a1 ': b) as)) #

class is ~ RImage as bs => USubset (as :: [u]) (bs :: [u]) is where #

Minimal complete definition

usubset | urelax, urestrict

Methods

usubset :: Prism' (Union f bs) (Union f as) #

urelax :: Union f as -> Union f bs #

urestrict :: Union f bs -> Maybe (Union f as) #

Instances

USubset u ([] u) bs ([] Nat) #
Methods usubset :: (Choice p, Applicative f) => p (Union [u] f bs) (f (Union [u] f bs)) -> p (Union [u] f [Nat]) (f (Union [u] f [Nat])) # urelax :: Union [u] f bs -> Union [u] f [Nat] # urestrict :: Union [u] f [Nat] -> Maybe (Union [u] f bs) #
(UElem u a bs i, USubset u as bs is) => USubset u ((:) u a as) bs ((:) Nat i is) #
Methods usubset :: (Choice p, Applicative f) => p (Union ((u ': a) as) f bs) (f (Union ((u ': a) as) f bs)) -> p (Union ((u ': a) as) f ((Nat ': i) is)) (f (Union ((u ': a) as) f ((Nat ': i) is))) # urelax :: Union ((u ': a) as) f bs -> Union ((u ': a) as) f ((Nat ': i) is) # urestrict :: Union ((u ': a) as) f ((Nat ': i) is) -> Maybe (Union ((u ': a) as) f bs) #

type OpenUnion = Union Identity #

openUnion :: forall a as. UElem a as (RIndex a as) => Prism' (OpenUnion as) a #