Data.OpenUnion

Open unions (type-indexed co-products) for extensible effects All operations are constant-time, and there is no Typeable constraint

This is a variation of OpenUion5.hs, which relies on overlapping instances instead of closed type families. Closed type families have their problems: overlapping instances can resolve even for unground types, but closed type families are subject to a strict apartness condition.

This implementation is very similar to OpenUnion1.hs, but without the annoying Typeable constraint. We sort of emulate it:

Our list r of open union components is a small Universe. Therefore, we can use the Typeable-like evidence in that universe. We hence can define

data Union r v where
  Union :: t v -> TRep t r -> Union r v -- t is existential

where

data TRep t r where
  T0 :: TRep t (t ': r)
  TS :: TRep t r -> TRep (any ': r)

Then Member is a type class that produces TRep Taken literally it doesn't seem much better than OpenUinion41.hs. However, we can cheat and use the index of the type t in the list r as the TRep. (We will need UnsafeCoerce then).

The interface is the same as of other OpenUnion*.hs

Documentation

data Union r v

inj :: Member t r => t v -> Union r v

prj :: Member t r => Union r v -> Maybe (t v)

decomp :: Union (t ': r) v -> Either (Union r v) (t v)

class FindElem t r => Member t r where

Minimal complete definition

inj, prj

Methods

inj :: t v -> Union r v

prj :: Union r v -> Maybe (t v)

Instances

FindElem [* -> *] t r => Member t r

Methods

inj :: t v -> Union * r v

prj :: Union * r v -> Maybe (t v)

class Member t r => SetMember tag t r | tag r -> t

This class is used for emulating monad transformers

Instances

(EQU Bool (* -> *) t1 t2 p, MemberU' k p tag t1 ((:) (* -> *) t2 r)) => SetMember k tag t1 ((:) (* -> *) t2 r)

weaken :: Union r w -> Union (any ': r) w