Safe Haskell | None |
---|---|
Language | Haskell2010 |
VariantF functor
Synopsis
- newtype VariantF (xs :: [* -> *]) e = VariantF (V (ApplyAll e xs))
- type family ApplyAll e (xs :: [* -> k]) :: [k] 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 r (xs :: [* -> *])
- algVariantF :: forall c e r (xs :: [* -> *]). AlgVariantF c e r xs => (forall (f :: * -> *). c f => f e -> r) -> VariantF xs e -> r
- 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 # | |
(Eq1 f, Eq1 (VariantF fs)) => Eq1 (VariantF (f ': fs)) Source # | |
Eq1 (VariantF ([] :: [Type -> Type])) Source # | |
(Ord1 f, Ord1 (VariantF fs)) => Ord1 (VariantF (f ': fs)) Source # | |
Defined in Haskus.Utils.VariantF | |
Ord1 (VariantF ([] :: [Type -> Type])) Source # | |
Defined in Haskus.Utils.VariantF | |
(Show1 f, Show1 (VariantF fs)) => Show1 (VariantF (f ': fs)) Source # | |
Show1 (VariantF ([] :: [Type -> Type])) Source # | |
NFData (VariantF xs (EADT xs)) => NFData (Fix (VariantF xs)) Source # | |
Defined in Haskus.Utils.EADT | |
(Eq1 (VariantF xs), ConstraintAll1 Eq1 xs, Eq e) => Eq (VariantF xs e) Source # | Eq instance for VariantF
|
(Ord1 (VariantF xs), ConstraintAll1 Ord1 xs, ConstraintAll1 Eq1 xs, Ord e) => Ord (VariantF xs e) Source # | Ord instance for VariantF
|
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 # | |
(Show1 (VariantF xs), ConstraintAll1 Show1 xs, Show e) => Show (VariantF xs e) Source # | Show instance for VariantF
|
NFData (V (ApplyAll e xs)) => NFData (VariantF xs e) Source # | |
Defined in Haskus.Utils.VariantF | |
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 :: [* -> k]) :: [k] 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 r (xs :: [* -> *]) Source #
algVariantF'
Instances
AlgVariantF c e r ([] :: [Type -> Type]) Source # | |
Defined in Haskus.Utils.VariantF algVariantF' :: (forall (f :: Type -> Type). c f => f e -> r) -> Word -> Any -> r | |
(AlgVariantF c e r xs, c x) => AlgVariantF c e r (x ': xs) Source # | |
Defined in Haskus.Utils.VariantF algVariantF' :: (forall (f :: Type -> Type). c f => f e -> r) -> Word -> Any -> r |
algVariantF :: forall c e r (xs :: [* -> *]). AlgVariantF c e r xs => (forall (f :: * -> *). c f => f e -> r) -> VariantF xs e -> r 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