Safe Haskell | None |
---|---|
Language | Haskell2010 |
Extensible ADT
Synopsis
- newtype VariantF (xs :: [* -> *]) e = VariantF (V (ApplyAll e xs))
- type family ApplyAll e (xs :: [* -> *]) :: [*] where ...
- pattern FV :: forall c cs e. Popable c (ApplyAll e cs) => c -> VariantF cs e
- 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
- toVariantFTail :: forall x xs e. VariantF xs e -> VariantF (x ': xs) e
- popVariantFHead :: forall x xs e. VariantF (x ': xs) e -> Either (VariantF xs e) (x e)
- popVariantF :: forall x xs ys e. (Popable (x e) (ApplyAll e xs), Filter (x e) (ApplyAll e xs) ~ ApplyAll e ys) => VariantF xs e -> Either (VariantF ys e) (x e)
- mapVariantF :: forall a b cs e ds as. (MappableVariant (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
- variantFToValue :: VariantF '[f] e -> f e
- type LiftableF e xs ys = (IsSubset xs ys ~ True, LiftVariant (ApplyAll e xs) (ApplyAll e ys))
- liftVariantF :: forall e as bs. LiftableF e as bs => VariantF as e -> VariantF bs e
- type EADT xs = Fix (VariantF xs)
- type family f :<: xs where ...
- pattern VF :: forall e f cs. (e ~ EADT cs, f :<: cs) => f (EADT cs) -> EADT cs
- 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
- liftEADT :: forall e as bs. (e ~ Fix (VariantF bs), LiftableF e as bs, Functor (VariantF as)) => EADT as -> EADT bs
- popEADT :: forall xs f e. (f :<: xs, e ~ EADT xs, Popable (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))
- module Haskus.Utils.Functor
Documentation
newtype VariantF (xs :: [* -> *]) e Source #
Recursive Functor-like Variant
Instances
(Functor (VariantF fs), Functor f) => Functor (VariantF (f ': fs)) Source # | |
Functor (VariantF ([] :: [* -> *])) Source # | |
Eq (V (ApplyAll e xs)) => Eq (VariantF xs e) Source # | |
Ord (V (ApplyAll e xs)) => Ord (VariantF xs e) Source # | |
Defined in Haskus.Utils.EADT 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 # | |
Show (V (ApplyAll e xs)) => Show (VariantF xs e) Source # | |
type family ApplyAll e (xs :: [* -> *]) :: [*] where ... Source #
`ApplyAll e '[f,g,h] ==> '[f e, g e, h e]`
pattern FV :: forall c cs e. Popable c (ApplyAll e cs) => c -> VariantF cs e Source #
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 Source #
toVariantFHead :: forall x xs e. x e -> VariantF (x ': xs) e Source #
Set the first value
toVariantFTail :: forall x xs e. VariantF xs e -> VariantF (x ': xs) e Source #
Set the tail
popVariantFHead :: forall x xs e. VariantF (x ': xs) e -> Either (VariantF xs e) (x e) Source #
Pop VariantF head
popVariantF :: forall x xs ys e. (Popable (x e) (ApplyAll e xs), Filter (x e) (ApplyAll e xs) ~ ApplyAll e ys) => VariantF xs e -> Either (VariantF ys e) (x e) Source #
Pop VariantF
mapVariantF :: forall a b cs e ds as. (MappableVariant (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 Source #
Map the matching types of a variant
variantFToValue :: VariantF '[f] e -> f e Source #
Retrieve a single value
type LiftableF e xs ys = (IsSubset xs ys ~ True, LiftVariant (ApplyAll e xs) (ApplyAll e ys)) Source #
xs is liftable in ys
liftVariantF :: forall e as bs. LiftableF e as bs => VariantF as e -> VariantF bs e Source #
Lift a VariantF into another
Extensible ADT
pattern VF :: forall e f cs. (e ~ EADT cs, f :<: cs) => f (EADT cs) -> EADT cs Source #
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 Source #
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 Source #
Lift an EADT into another
popEADT :: forall xs f e. (f :<: xs, e ~ EADT xs, Popable (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)) Source #
Pop an EADT value
Reexport
module Haskus.Utils.Functor