Haskus.Utils.EADT

Extensible ADT

Documentation

newtype VariantF (xs :: [* -> *]) e

Recursive Functor-like Variant

Constructors

VariantF (V (ApplyAll e xs))

Instances

(Functor (VariantF fs), Functor f) => Functor (VariantF (f ': fs))

Defined in Haskus.Utils.EADT

Methods

fmap :: (a -> b) -> VariantF (f ': fs) a -> VariantF (f ': fs) b

(<$) :: a -> VariantF (f ': fs) b -> VariantF (f ': fs) a

Functor (VariantF ([] :: [* -> *]))

Defined in Haskus.Utils.EADT

Methods

fmap :: (a -> b) -> VariantF [] a -> VariantF [] b

(<$) :: a -> VariantF [] b -> VariantF [] a

Eq (V (ApplyAll e xs)) => Eq (VariantF xs e)

Defined in Haskus.Utils.EADT

Methods

(==) :: VariantF xs e -> VariantF xs e -> Bool

(/=) :: VariantF xs e -> VariantF xs e -> Bool

Ord (V (ApplyAll e xs)) => Ord (VariantF xs e)

Defined in Haskus.Utils.EADT

Methods

compare :: VariantF xs e -> VariantF xs e -> Ordering

(<) :: VariantF xs e -> VariantF xs e -> Bool

(<=) :: VariantF xs e -> VariantF xs e -> Bool

(>) :: VariantF xs e -> VariantF xs e -> Bool

(>=) :: VariantF xs e -> VariantF xs e -> Bool

max :: VariantF xs e -> VariantF xs e -> VariantF xs e

min :: VariantF xs e -> VariantF xs e -> VariantF xs e

Show (V (ApplyAll e xs)) => Show (VariantF xs e)

Defined in Haskus.Utils.EADT

Methods

showsPrec :: Int -> VariantF xs e -> ShowS

show :: VariantF xs e -> String

showList :: [VariantF xs e] -> ShowS

type family ApplyAll e (xs :: [* -> *]) :: [*] where ...

Apply its first argument to every element of the 2nd arg list

ApplyAll e '[f,g,h] ==> '[f e, g e, h e]

Equations

ApplyAll e '[] = '[]

ApplyAll e (f ': fs) = f e ': ApplyAll e fs

pattern FV :: forall c cs e. c :< ApplyAll e cs => c -> VariantF cs e

Pattern-match in a VariantF

appendVariantF :: forall (ys :: [* -> *]) (xs :: [* -> *]) e. ApplyAll e (Concat xs ys) ~ Concat (ApplyAll e xs) (ApplyAll e ys) => VariantF xs e -> VariantF (Concat xs ys) e

toVariantFHead :: forall x xs e. x e -> VariantF (x ': xs) e

Set the first value

toVariantFTail :: forall x xs e. VariantF xs e -> VariantF (x ': xs) e

Set the tail

popVariantFHead :: forall x xs e. VariantF (x ': xs) e -> Either (VariantF xs e) (x e)

Pop VariantF head

popVariantF :: forall x xs ys e. (x e :< ApplyAll e xs, Filter (x e) (ApplyAll e xs) ~ ApplyAll e ys) => VariantF xs e -> Either (VariantF ys e) (x e)

Pop VariantF

mapVariantF :: forall a b cs e ds as. (MapVariant (a e) (b e) as, ds ~ ReplaceNS (IndexesOf a cs) b cs, as ~ ApplyAll e cs, ApplyAll e ds ~ ReplaceNS (IndexesOf (a e) as) (b e) as) => (a e -> b e) -> VariantF cs e -> VariantF ds e

Map the matching types of a variant

variantFToValue :: VariantF '[f] e -> f e

Retrieve a single value

type LiftableF e xs ys = (IsSubset xs ys ~ True, LiftVariant (ApplyAll e xs) (ApplyAll e ys))

xs is liftable in ys

liftVariantF :: forall e as bs. LiftableF e as bs => VariantF as e -> VariantF bs e

Lift a VariantF into another

class AlterVariantF (c :: (* -> *) -> Constraint) e (xs :: [* -> *])

Minimal complete definition

alterVariantF'

Instances

AlterVariantF c e ([] :: [* -> *])

Defined in Haskus.Utils.EADT

Methods

alterVariantF' :: (forall (f :: * -> *). c f => f e -> f e) -> Word -> Any -> Any

(AlterVariantF c e xs, c x) => AlterVariantF c e (x ': xs)

Defined in Haskus.Utils.EADT

Methods

alterVariantF' :: (forall (f :: * -> *). c f => f e -> f e) -> Word -> Any -> Any

alterVariantF :: forall c e (xs :: [* -> *]). AlterVariantF c e xs => (forall (f :: * -> *). c f => f e -> f e) -> VariantF xs e -> VariantF xs e

Alter a variant. You need to specify the constraints required by the modifying function.

Usage:

  alterVariantF @NoConstraint id         v
  alterVariantF @Resizable    (resize 4) v

  -- Multiple constraints:
  class (Ord a, Num a) => OrdNum a
  instance (Ord a, Num a) => OrdNum a
  alterVariantF @OrdNum foo v

class AlgVariantF (c :: (* -> *) -> Constraint) e (xs :: [* -> *])

Minimal complete definition

algVariantF'

Instances

AlgVariantF c e ([] :: [* -> *])

Defined in Haskus.Utils.EADT

Methods

algVariantF' :: (forall (f :: * -> *). c f => f e -> e) -> Word -> Any -> e

(AlgVariantF c e xs, c x) => AlgVariantF c e (x ': xs)

Defined in Haskus.Utils.EADT

Methods

algVariantF' :: (forall (f :: * -> *). c f => f e -> e) -> Word -> Any -> e

algVariantF :: forall c e (xs :: [* -> *]). AlgVariantF c e xs => (forall (f :: * -> *). c f => f e -> e) -> VariantF xs e -> e

Apply an algebra to a VariantF. You need to specify the constraints required by the modifying function.

Usage:

 algVariantF @NoConstraint id         v
 algVariantF @Resizable    (resize 4) v

splitVariantF :: forall as xs e. (Complement (ApplyAll e xs) (ApplyAll e as) ~ ApplyAll e (Complement xs as), SplitVariant (ApplyAll e as) (ApplyAll e xs) (ApplyAll e xs)) => VariantF xs e -> Either (VariantF as e) (VariantF (Complement xs as) e)

Split a VariantF in two

variantFToCont :: ContVariant (ApplyAll e xs) => VariantF xs e -> ContFlow (ApplyAll e xs) r

Convert a VariantF into a multi-continuation

variantFToContM :: (ContVariant (ApplyAll e xs), Monad m) => m (VariantF xs e) -> ContFlow (ApplyAll e xs) (m r)

Convert a VariantF into a multi-continuation

contToVariantF :: forall xs e. ContVariant (ApplyAll e xs) => ContFlow (ApplyAll e xs) (V (ApplyAll e xs)) -> VariantF xs e

Convert a multi-continuation into a VariantF

contToVariantFM :: forall xs e m. (ContVariant (ApplyAll e xs), Monad m) => ContFlow (ApplyAll e xs) (m (V (ApplyAll e xs))) -> m (VariantF xs e)

Convert a multi-continuation into a VariantF

Extensible ADT

type EADT xs = Fix (VariantF xs)

An extensible ADT

type family f :<: xs where ...

Equations

f :<: xs = EADTF' f (EADT xs) xs

pattern VF :: forall e f cs. (e ~ EADT cs, f :<: cs) => f (EADT cs) -> EADT cs

Pattern-match in an extensible ADT

appendEADT :: forall ys xs zs. (zs ~ Concat xs ys, ApplyAll (EADT zs) zs ~ Concat (ApplyAll (EADT zs) xs) (ApplyAll (EADT zs) ys), Functor (VariantF xs)) => EADT xs -> EADT zs

Append new "constructors" to the EADT

liftEADT :: forall e as bs. (e ~ Fix (VariantF bs), LiftableF e as bs, Functor (VariantF as)) => EADT as -> EADT bs

Lift an EADT into another

popEADT :: forall xs f e. (f :<: xs, e ~ EADT xs, f e :< ApplyAll e xs, Filter (f e) (ApplyAll e xs) ~ ApplyAll e (Filter f xs)) => EADT xs -> Either (VariantF (Filter f xs) (EADT xs)) (f (EADT xs))

Pop an EADT value

type AlterEADT c xs = AlterVariantF c (EADT xs) xs

alterEADT :: forall c xs. AlterEADT c xs => (forall f. c f => f (EADT xs) -> f (EADT xs)) -> EADT xs -> EADT xs

Alter an EADT value

type AlgEADT c xs = AlgVariantF c (EADT xs) xs

algEADT :: forall c xs. AlgEADT c xs => (forall f. c f => f (EADT xs) -> EADT xs) -> EADT xs -> EADT xs

Apply an algebra to an EADT value

eadtToCont :: ContVariant (ApplyAll (Fix (VariantF xs)) xs) => Fix (VariantF xs) -> ContFlow (ApplyAll (Fix (VariantF xs)) xs) r

Convert an EADT into a multi-continuation

eadtToContM :: (ContVariant (ApplyAll (Fix (VariantF xs)) xs), Monad m) => m (Fix (VariantF xs)) -> ContFlow (ApplyAll (Fix (VariantF xs)) xs) (m r)

Convert an EADT into a multi-continuation

contToEADT :: ContVariant (ApplyAll (Fix (VariantF xs)) xs) => ContFlow (ApplyAll (Fix (VariantF xs)) xs) (V (ApplyAll (Fix (VariantF xs)) xs)) -> Fix (VariantF xs)

Convert a multi-continuation into an EADT

contToEADTM :: (ContVariant (ApplyAll (Fix (VariantF xs)) xs), Monad f) => ContFlow (ApplyAll (Fix (VariantF xs)) xs) (f (V (ApplyAll (Fix (VariantF xs)) xs))) -> f (Fix (VariantF xs))

Convert a multi-continuation into an EADT

Reexport

class NoConstraint a

Useful to specify a "* -> Constraint" function returning an empty constraint

Instances

NoConstraint a

Defined in Haskus.Utils.Variant

module Haskus.Utils.Functor