Safe Haskell | None |
---|---|
Language | Haskell2010 |
VariantF functor
Synopsis
- newtype VariantF (xs :: [* -> *]) e = VariantF (V (ApplyAll e xs))
- type family ApplyAll e (xs :: [* -> *]) :: [*] where ...
- pattern FV :: forall c cs e. 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)
- variantFToValue :: VariantF '[f] e -> f e
- type MapVariantF a b cs ds e = (MapVariant (a e) (b e) (ApplyAll e cs), ds ~ ReplaceNS (IndexesOf a cs) b cs, ApplyAll e ds ~ ReplaceNS (IndexesOf (a e) (ApplyAll e cs)) (b e) (ApplyAll e cs))
- mapVariantF :: forall a b cs ds e. MapVariantF a b cs ds e => (a e -> b e) -> VariantF cs e -> VariantF ds e
- type PopVariantF x xs e = (x e :< ApplyAll e xs, Remove (x e) (ApplyAll e xs) ~ ApplyAll e (Remove x xs))
- popVariantF :: forall x xs e. PopVariantF x xs e => VariantF xs e -> Either (VariantF (Remove x xs) e) (x e)
- type LiftVariantF xs ys e = LiftVariant (ApplyAll e xs) (ApplyAll e ys)
- liftVariantF :: forall as bs e. LiftVariantF as bs e => VariantF as e -> VariantF bs e
- class AlterVariantF (c :: (* -> *) -> Constraint) e (xs :: [* -> *])
- alterVariantF :: forall c e (xs :: [* -> *]). AlterVariantF c e xs => (forall (f :: * -> *). c f => f e -> f e) -> VariantF xs e -> VariantF xs e
- class AlgVariantF (c :: (* -> *) -> Constraint) e (xs :: [* -> *])
- algVariantF :: forall c e (xs :: [* -> *]). AlgVariantF c e xs => (forall (f :: * -> *). c f => f e -> e) -> VariantF xs e -> e
- type SplitVariantF as xs e = (Complement (ApplyAll e xs) (ApplyAll e as) ~ ApplyAll e (Complement xs as), SplitVariant (ApplyAll e as) (ApplyAll e (Complement xs as)) (ApplyAll e xs))
- splitVariantF :: forall as xs e. SplitVariantF as xs e => VariantF xs e -> Either (VariantF (Complement xs as) e) (VariantF as e)
- variantFToCont :: ContVariant (ApplyAll e xs) => VariantF xs e -> ContFlow (ApplyAll e xs) r
- variantFToContM :: (ContVariant (ApplyAll e xs), Monad m) => m (VariantF xs e) -> ContFlow (ApplyAll e xs) (m r)
- contToVariantF :: forall xs e. ContVariant (ApplyAll e xs) => ContFlow (ApplyAll e xs) (V (ApplyAll e xs)) -> VariantF xs e
- contToVariantFM :: forall xs e m. (ContVariant (ApplyAll e xs), Monad m) => ContFlow (ApplyAll e xs) (m (V (ApplyAll e xs))) -> m (VariantF xs e)
- class NoConstraint a
- 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 ([] :: [Type -> Type])) 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.VariantF 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 # | |
ContVariant (ApplyAll e xs) => MultiCont (VariantF xs e) Source # | |
type MultiContTypes (VariantF xs e) Source # | |
Defined in Haskus.Utils.VariantF |
type family ApplyAll e (xs :: [* -> *]) :: [*] where ... Source #
Apply its first argument to every element of the 2nd arg list
ApplyAll e '[f,g,h] ==> '[f e, g e, h e]
pattern FV :: forall c cs e. 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
variantFToValue :: VariantF '[f] e -> f e Source #
Retrieve a single value
type MapVariantF a b cs ds e = (MapVariant (a e) (b e) (ApplyAll e cs), ds ~ ReplaceNS (IndexesOf a cs) b cs, ApplyAll e ds ~ ReplaceNS (IndexesOf (a e) (ApplyAll e cs)) (b e) (ApplyAll e cs)) Source #
mapVariantF :: forall a b cs ds e. MapVariantF a b cs ds e => (a e -> b e) -> VariantF cs e -> VariantF ds e Source #
Map the matching types of a variant
type PopVariantF x xs e = (x e :< ApplyAll e xs, Remove (x e) (ApplyAll e xs) ~ ApplyAll e (Remove x xs)) Source #
popVariantF :: forall x xs e. PopVariantF x xs e => VariantF xs e -> Either (VariantF (Remove x xs) e) (x e) Source #
Pop VariantF
type LiftVariantF xs ys e = LiftVariant (ApplyAll e xs) (ApplyAll e ys) Source #
xs is liftable in ys
liftVariantF :: forall as bs e. LiftVariantF as bs e => VariantF as e -> VariantF bs e Source #
Lift a VariantF into another
class AlterVariantF (c :: (* -> *) -> Constraint) e (xs :: [* -> *]) Source #
alterVariantF'
Instances
AlterVariantF c e ([] :: [Type -> Type]) Source # | |
Defined in Haskus.Utils.VariantF | |
(AlterVariantF c e xs, c x) => AlterVariantF c e (x ': xs) Source # | |
Defined in Haskus.Utils.VariantF |
alterVariantF :: forall c e (xs :: [* -> *]). AlterVariantF c e xs => (forall (f :: * -> *). c f => f e -> f e) -> VariantF xs e -> VariantF xs e Source #
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 :: [* -> *]) Source #
algVariantF'
Instances
AlgVariantF c e ([] :: [Type -> Type]) Source # | |
Defined in Haskus.Utils.VariantF algVariantF' :: (forall (f :: Type -> Type). c f => f e -> e) -> Word -> Any -> e | |
(AlgVariantF c e xs, c x) => AlgVariantF c e (x ': xs) Source # | |
Defined in Haskus.Utils.VariantF algVariantF' :: (forall (f :: Type -> Type). 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 Source #
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
type SplitVariantF as xs e = (Complement (ApplyAll e xs) (ApplyAll e as) ~ ApplyAll e (Complement xs as), SplitVariant (ApplyAll e as) (ApplyAll e (Complement xs as)) (ApplyAll e xs)) Source #
splitVariantF :: forall as xs e. SplitVariantF as xs e => VariantF xs e -> Either (VariantF (Complement xs as) e) (VariantF as e) Source #
Split a VariantF in two
variantFToCont :: ContVariant (ApplyAll e xs) => VariantF xs e -> ContFlow (ApplyAll e xs) r Source #
Convert a VariantF into a multi-continuation
variantFToContM :: (ContVariant (ApplyAll e xs), Monad m) => m (VariantF xs e) -> ContFlow (ApplyAll e xs) (m r) Source #
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 Source #
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) Source #
Convert a multi-continuation into a VariantF
Reexport
class NoConstraint a Source #
Useful to specify a "* -> Constraint" function returning an empty constraint
Instances
NoConstraint a Source # | |
Defined in Haskus.Utils.Variant |
module Haskus.Utils.Functor