Control.Functor.Expansive

Expand

class Expansive (f :: Type -> Type) where

Partial inverse of Compactable

expand (unite x y) = uniteDichotomy x y

unite = emapThese id

map Just = expand

(\x -> unite x x) = map (\x -> These x x)

emapThese f a b = map f (unite a b)

unite (f <$> x) (g <$> y) = bimap f g <$> unite x y

expand (unite x y) = swap <$> unite y x

emapThese f a b = f <$> unite a b

unite empty = map That

flip unite empty = map This

unite mempty = map That

flip unite mempty = map This

Minimal complete definition

unite | emapThese

Methods

expand :: f a -> f (Maybe a)

default expand :: Functor f => f a -> f (Maybe a)

unite :: f l -> f r -> f (These l r)

unfilter :: (Bool -> a) -> f a -> f a

emapMaybe :: (Maybe b -> a) -> f b -> f a

default emapMaybe :: Functor f => (Maybe b -> a) -> f b -> f a

econtramapMaybe :: Contravariant f => (a -> Maybe b) -> f b -> f a

emapThese :: (These l r -> a) -> f l -> f r -> f a

default emapThese :: Functor f => (These l r -> a) -> f l -> f r -> f a

econtramapThese :: Contravariant f => (a -> These l r) -> f l -> f r -> f a

eapplyMaybe :: Applicative f => f (Maybe a -> b) -> f a -> f b

eapplyThese :: Applicative f => f (These l r -> a) -> f l -> f r -> f a

ebindMaybe :: Applicative f => (f (Maybe b) -> a) -> f b -> f a

ebindThese :: Applicative f => (f (These l r) -> a) -> f l -> f r -> f a

Instances

Expansive []

Defined in Control.Functor.Expansive

Methods

expand :: [a] -> [Maybe a]

unite :: [l] -> [r] -> [These l r]

unfilter :: (Bool -> a) -> [a] -> [a]

emapMaybe :: (Maybe b -> a) -> [b] -> [a]

econtramapMaybe :: Contravariant [] => (a -> Maybe b) -> [b] -> [a]

emapThese :: (These l r -> a) -> [l] -> [r] -> [a]

econtramapThese :: Contravariant [] => (a -> These l r) -> [l] -> [r] -> [a]

eapplyMaybe :: Applicative [] => [Maybe a -> b] -> [a] -> [b]

eapplyThese :: Applicative [] => [These l r -> a] -> [l] -> [r] -> [a]

ebindMaybe :: Applicative [] => ([Maybe b] -> a) -> [b] -> [a]

ebindThese :: Applicative [] => ([These l r] -> a) -> [l] -> [r] -> [a]

Expansive Maybe

Defined in Control.Functor.Expansive

Methods

expand :: Maybe a -> Maybe (Maybe a)

unite :: Maybe l -> Maybe r -> Maybe (These l r)

unfilter :: (Bool -> a) -> Maybe a -> Maybe a

emapMaybe :: (Maybe b -> a) -> Maybe b -> Maybe a

econtramapMaybe :: Contravariant Maybe => (a -> Maybe b) -> Maybe b -> Maybe a

emapThese :: (These l r -> a) -> Maybe l -> Maybe r -> Maybe a

econtramapThese :: Contravariant Maybe => (a -> These l r) -> Maybe l -> Maybe r -> Maybe a

eapplyMaybe :: Applicative Maybe => Maybe (Maybe a -> b) -> Maybe a -> Maybe b

eapplyThese :: Applicative Maybe => Maybe (These l r -> a) -> Maybe l -> Maybe r -> Maybe a

ebindMaybe :: Applicative Maybe => (Maybe (Maybe b) -> a) -> Maybe b -> Maybe a

ebindThese :: Applicative Maybe => (Maybe (These l r) -> a) -> Maybe l -> Maybe r -> Maybe a

Expansive Option

Defined in Control.Functor.Expansive

Methods

expand :: Option a -> Option (Maybe a)

unite :: Option l -> Option r -> Option (These l r)

unfilter :: (Bool -> a) -> Option a -> Option a

emapMaybe :: (Maybe b -> a) -> Option b -> Option a

econtramapMaybe :: Contravariant Option => (a -> Maybe b) -> Option b -> Option a

emapThese :: (These l r -> a) -> Option l -> Option r -> Option a

econtramapThese :: Contravariant Option => (a -> These l r) -> Option l -> Option r -> Option a

eapplyMaybe :: Applicative Option => Option (Maybe a -> b) -> Option a -> Option b

eapplyThese :: Applicative Option => Option (These l r -> a) -> Option l -> Option r -> Option a

ebindMaybe :: Applicative Option => (Option (Maybe b) -> a) -> Option b -> Option a

ebindThese :: Applicative Option => (Option (These l r) -> a) -> Option l -> Option r -> Option a

Expansive ZipList

Defined in Control.Functor.Expansive

Methods

expand :: ZipList a -> ZipList (Maybe a)

unite :: ZipList l -> ZipList r -> ZipList (These l r)

unfilter :: (Bool -> a) -> ZipList a -> ZipList a

emapMaybe :: (Maybe b -> a) -> ZipList b -> ZipList a

econtramapMaybe :: Contravariant ZipList => (a -> Maybe b) -> ZipList b -> ZipList a

emapThese :: (These l r -> a) -> ZipList l -> ZipList r -> ZipList a

econtramapThese :: Contravariant ZipList => (a -> These l r) -> ZipList l -> ZipList r -> ZipList a

eapplyMaybe :: Applicative ZipList => ZipList (Maybe a -> b) -> ZipList a -> ZipList b

eapplyThese :: Applicative ZipList => ZipList (These l r -> a) -> ZipList l -> ZipList r -> ZipList a

ebindMaybe :: Applicative ZipList => (ZipList (Maybe b) -> a) -> ZipList b -> ZipList a

ebindThese :: Applicative ZipList => (ZipList (These l r) -> a) -> ZipList l -> ZipList r -> ZipList a

Expansive IntMap

Defined in Control.Functor.Expansive

Methods

expand :: IntMap a -> IntMap (Maybe a)

unite :: IntMap l -> IntMap r -> IntMap (These l r)

unfilter :: (Bool -> a) -> IntMap a -> IntMap a

emapMaybe :: (Maybe b -> a) -> IntMap b -> IntMap a

econtramapMaybe :: Contravariant IntMap => (a -> Maybe b) -> IntMap b -> IntMap a

emapThese :: (These l r -> a) -> IntMap l -> IntMap r -> IntMap a

econtramapThese :: Contravariant IntMap => (a -> These l r) -> IntMap l -> IntMap r -> IntMap a

eapplyMaybe :: Applicative IntMap => IntMap (Maybe a -> b) -> IntMap a -> IntMap b

eapplyThese :: Applicative IntMap => IntMap (These l r -> a) -> IntMap l -> IntMap r -> IntMap a

ebindMaybe :: Applicative IntMap => (IntMap (Maybe b) -> a) -> IntMap b -> IntMap a

ebindThese :: Applicative IntMap => (IntMap (These l r) -> a) -> IntMap l -> IntMap r -> IntMap a

Expansive Seq

Defined in Control.Functor.Expansive

Methods

expand :: Seq a -> Seq (Maybe a)

unite :: Seq l -> Seq r -> Seq (These l r)

unfilter :: (Bool -> a) -> Seq a -> Seq a

emapMaybe :: (Maybe b -> a) -> Seq b -> Seq a

econtramapMaybe :: Contravariant Seq => (a -> Maybe b) -> Seq b -> Seq a

emapThese :: (These l r -> a) -> Seq l -> Seq r -> Seq a

econtramapThese :: Contravariant Seq => (a -> These l r) -> Seq l -> Seq r -> Seq a

eapplyMaybe :: Applicative Seq => Seq (Maybe a -> b) -> Seq a -> Seq b

eapplyThese :: Applicative Seq => Seq (These l r -> a) -> Seq l -> Seq r -> Seq a

ebindMaybe :: Applicative Seq => (Seq (Maybe b) -> a) -> Seq b -> Seq a

ebindThese :: Applicative Seq => (Seq (These l r) -> a) -> Seq l -> Seq r -> Seq a

Expansive Vector

Defined in Control.Functor.Expansive

Methods

expand :: Vector a -> Vector (Maybe a)

unite :: Vector l -> Vector r -> Vector (These l r)

unfilter :: (Bool -> a) -> Vector a -> Vector a

emapMaybe :: (Maybe b -> a) -> Vector b -> Vector a

econtramapMaybe :: Contravariant Vector => (a -> Maybe b) -> Vector b -> Vector a

emapThese :: (These l r -> a) -> Vector l -> Vector r -> Vector a

econtramapThese :: Contravariant Vector => (a -> These l r) -> Vector l -> Vector r -> Vector a

eapplyMaybe :: Applicative Vector => Vector (Maybe a -> b) -> Vector a -> Vector b

eapplyThese :: Applicative Vector => Vector (These l r -> a) -> Vector l -> Vector r -> Vector a

ebindMaybe :: Applicative Vector => (Vector (Maybe b) -> a) -> Vector b -> Vector a

ebindThese :: Applicative Vector => (Vector (These l r) -> a) -> Vector l -> Vector r -> Vector a

Ord k => Expansive (Map k)

Defined in Control.Functor.Expansive

Methods

expand :: Map k a -> Map k (Maybe a)

unite :: Map k l -> Map k r -> Map k (These l r)

unfilter :: (Bool -> a) -> Map k a -> Map k a

emapMaybe :: (Maybe b -> a) -> Map k b -> Map k a

econtramapMaybe :: Contravariant (Map k) => (a -> Maybe b) -> Map k b -> Map k a

emapThese :: (These l r -> a) -> Map k l -> Map k r -> Map k a

econtramapThese :: Contravariant (Map k) => (a -> These l r) -> Map k l -> Map k r -> Map k a

eapplyMaybe :: Applicative (Map k) => Map k (Maybe a -> b) -> Map k a -> Map k b

eapplyThese :: Applicative (Map k) => Map k (These l r -> a) -> Map k l -> Map k r -> Map k a

ebindMaybe :: Applicative (Map k) => (Map k (Maybe b) -> a) -> Map k b -> Map k a

ebindThese :: Applicative (Map k) => (Map k (These l r) -> a) -> Map k l -> Map k r -> Map k a

Expansive (Proxy :: Type -> Type)

Defined in Control.Functor.Expansive

Methods

expand :: Proxy a -> Proxy (Maybe a)

unite :: Proxy l -> Proxy r -> Proxy (These l r)

unfilter :: (Bool -> a) -> Proxy a -> Proxy a

emapMaybe :: (Maybe b -> a) -> Proxy b -> Proxy a

econtramapMaybe :: Contravariant Proxy => (a -> Maybe b) -> Proxy b -> Proxy a

emapThese :: (These l r -> a) -> Proxy l -> Proxy r -> Proxy a

econtramapThese :: Contravariant Proxy => (a -> These l r) -> Proxy l -> Proxy r -> Proxy a

eapplyMaybe :: Applicative Proxy => Proxy (Maybe a -> b) -> Proxy a -> Proxy b

eapplyThese :: Applicative Proxy => Proxy (These l r -> a) -> Proxy l -> Proxy r -> Proxy a

ebindMaybe :: Applicative Proxy => (Proxy (Maybe b) -> a) -> Proxy b -> Proxy a

ebindThese :: Applicative Proxy => (Proxy (These l r) -> a) -> Proxy l -> Proxy r -> Proxy a

Monad m => Expansive (Stream m)

Defined in Control.Functor.Expansive

Methods

expand :: Stream m a -> Stream m (Maybe a)

unite :: Stream m l -> Stream m r -> Stream m (These l r)

unfilter :: (Bool -> a) -> Stream m a -> Stream m a

emapMaybe :: (Maybe b -> a) -> Stream m b -> Stream m a

econtramapMaybe :: Contravariant (Stream m) => (a -> Maybe b) -> Stream m b -> Stream m a

emapThese :: (These l r -> a) -> Stream m l -> Stream m r -> Stream m a

econtramapThese :: Contravariant (Stream m) => (a -> These l r) -> Stream m l -> Stream m r -> Stream m a

eapplyMaybe :: Applicative (Stream m) => Stream m (Maybe a -> b) -> Stream m a -> Stream m b

eapplyThese :: Applicative (Stream m) => Stream m (These l r -> a) -> Stream m l -> Stream m r -> Stream m a

ebindMaybe :: Applicative (Stream m) => (Stream m (Maybe b) -> a) -> Stream m b -> Stream m a

ebindThese :: Applicative (Stream m) => (Stream m (These l r) -> a) -> Stream m l -> Stream m r -> Stream m a

Monad m => Expansive (Bundle m v)

Defined in Control.Functor.Expansive

Methods

expand :: Bundle m v a -> Bundle m v (Maybe a)

unite :: Bundle m v l -> Bundle m v r -> Bundle m v (These l r)

unfilter :: (Bool -> a) -> Bundle m v a -> Bundle m v a

emapMaybe :: (Maybe b -> a) -> Bundle m v b -> Bundle m v a

econtramapMaybe :: Contravariant (Bundle m v) => (a -> Maybe b) -> Bundle m v b -> Bundle m v a

emapThese :: (These l r -> a) -> Bundle m v l -> Bundle m v r -> Bundle m v a

econtramapThese :: Contravariant (Bundle m v) => (a -> These l r) -> Bundle m v l -> Bundle m v r -> Bundle m v a

eapplyMaybe :: Applicative (Bundle m v) => Bundle m v (Maybe a -> b) -> Bundle m v a -> Bundle m v b

eapplyThese :: Applicative (Bundle m v) => Bundle m v (These l r -> a) -> Bundle m v l -> Bundle m v r -> Bundle m v a

ebindMaybe :: Applicative (Bundle m v) => (Bundle m v (Maybe b) -> a) -> Bundle m v b -> Bundle m v a

ebindThese :: Applicative (Bundle m v) => (Bundle m v (These l r) -> a) -> Bundle m v l -> Bundle m v r -> Bundle m v a

(Functor f, Functor g, Expansive f, Expansive g) => Expansive (Product f g)

Defined in Control.Functor.Expansive

Methods

expand :: Product f g a -> Product f g (Maybe a)

unite :: Product f g l -> Product f g r -> Product f g (These l r)

unfilter :: (Bool -> a) -> Product f g a -> Product f g a

emapMaybe :: (Maybe b -> a) -> Product f g b -> Product f g a

econtramapMaybe :: Contravariant (Product f g) => (a -> Maybe b) -> Product f g b -> Product f g a

emapThese :: (These l r -> a) -> Product f g l -> Product f g r -> Product f g a

econtramapThese :: Contravariant (Product f g) => (a -> These l r) -> Product f g l -> Product f g r -> Product f g a

eapplyMaybe :: Applicative (Product f g) => Product f g (Maybe a -> b) -> Product f g a -> Product f g b

eapplyThese :: Applicative (Product f g) => Product f g (These l r -> a) -> Product f g l -> Product f g r -> Product f g a

ebindMaybe :: Applicative (Product f g) => (Product f g (Maybe b) -> a) -> Product f g b -> Product f g a

ebindThese :: Applicative (Product f g) => (Product f g (These l r) -> a) -> Product f g l -> Product f g r -> Product f g a

uniteDichotomy :: (Functor f, Expansive f, Dichotomous g) => f l -> f r -> f (Maybe (g l r))