Control.Functor.Elastic

Documentation

class Expansive (f :: Type -> Type)

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

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

class Compactable (f :: Type -> Type)

A generalization of catMaybes

compact . map Just = id

compact . mapMaybe id

compact (pure Just <*> a) = a

applyMaybe (pure Just) = id

applyMaybe (pure id) = compact

bindMaybe (return . Just) = id

bindMaybe return = compact

compact (return . Just =<< a) = a

mapMaybe (l <=< r) = mapMaybe l . mapMaybe r

compact (Nothing <$ a) = empty

compact (Nothing <$ a) = mempty

compact empty = empty

compact mempty = mempty

traverseMaybe (Just . Just) = Just

traverseMaybe (map Just . f) = traverse f

Minimal complete definition

compact | separateThese

Instances

Compactable []

Defined in Control.Functor.Compactable

Methods

compact :: [Maybe a] -> [a]

separateThese :: [These l r] -> ([l], [r])

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

partition :: (a -> Bool) -> [a] -> ([a], [a])

mapMaybe :: Functor [] => (a -> Maybe b) -> [a] -> [b]

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

mapThese :: Functor [] => (a -> These l r) -> [a] -> ([l], [r])

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

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

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

bindMaybe :: Monad [] => (a -> [Maybe b]) -> [a] -> [b]

bindThese :: Monad [] => (a -> [These l r]) -> [a] -> ([l], [r])

traverseMaybe :: (Applicative g, Traversable []) => (a -> g (Maybe b)) -> [a] -> g [b]

traverseThese :: (Applicative g, Traversable []) => (a -> g (These l r)) -> [a] -> g ([l], [r])

Compactable Maybe

Defined in Control.Functor.Compactable

Methods

compact :: Maybe (Maybe a) -> Maybe a

separateThese :: Maybe (These l r) -> (Maybe l, Maybe r)

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

partition :: (a -> Bool) -> Maybe a -> (Maybe a, Maybe a)

mapMaybe :: Functor Maybe => (a -> Maybe b) -> Maybe a -> Maybe b

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

mapThese :: Functor Maybe => (a -> These l r) -> Maybe a -> (Maybe l, Maybe r)

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

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

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

bindMaybe :: Monad Maybe => (a -> Maybe (Maybe b)) -> Maybe a -> Maybe b

bindThese :: Monad Maybe => (a -> Maybe (These l r)) -> Maybe a -> (Maybe l, Maybe r)

traverseMaybe :: (Applicative g, Traversable Maybe) => (a -> g (Maybe b)) -> Maybe a -> g (Maybe b)

traverseThese :: (Applicative g, Traversable Maybe) => (a -> g (These l r)) -> Maybe a -> g (Maybe l, Maybe r)

Compactable IO

Defined in Control.Functor.Compactable

Methods

compact :: IO (Maybe a) -> IO a

separateThese :: IO (These l r) -> (IO l, IO r)

filter :: (a -> Bool) -> IO a -> IO a

partition :: (a -> Bool) -> IO a -> (IO a, IO a)

mapMaybe :: Functor IO => (a -> Maybe b) -> IO a -> IO b

contramapMaybe :: Contravariant IO => (Maybe b -> a) -> IO a -> IO b

mapThese :: Functor IO => (a -> These l r) -> IO a -> (IO l, IO r)

contramapThese :: Contravariant IO => (These l r -> a) -> IO a -> (IO l, IO r)

applyMaybe :: Applicative IO => IO (a -> Maybe b) -> IO a -> IO b

applyThese :: Applicative IO => IO (a -> These l r) -> IO a -> (IO l, IO r)

bindMaybe :: Monad IO => (a -> IO (Maybe b)) -> IO a -> IO b

bindThese :: Monad IO => (a -> IO (These l r)) -> IO a -> (IO l, IO r)

traverseMaybe :: (Applicative g, Traversable IO) => (a -> g (Maybe b)) -> IO a -> g (IO b)

traverseThese :: (Applicative g, Traversable IO) => (a -> g (These l r)) -> IO a -> g (IO l, IO r)

Compactable Option

Defined in Control.Functor.Compactable

Methods

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

separateThese :: Option (These l r) -> (Option l, Option r)

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

partition :: (a -> Bool) -> Option a -> (Option a, Option a)

mapMaybe :: Functor Option => (a -> Maybe b) -> Option a -> Option b

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

mapThese :: Functor Option => (a -> These l r) -> Option a -> (Option l, Option r)

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

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

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

bindMaybe :: Monad Option => (a -> Option (Maybe b)) -> Option a -> Option b

bindThese :: Monad Option => (a -> Option (These l r)) -> Option a -> (Option l, Option r)

traverseMaybe :: (Applicative g, Traversable Option) => (a -> g (Maybe b)) -> Option a -> g (Option b)

traverseThese :: (Applicative g, Traversable Option) => (a -> g (These l r)) -> Option a -> g (Option l, Option r)

Compactable ZipList

Defined in Control.Functor.Compactable

Methods

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

separateThese :: ZipList (These l r) -> (ZipList l, ZipList r)

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

partition :: (a -> Bool) -> ZipList a -> (ZipList a, ZipList a)

mapMaybe :: Functor ZipList => (a -> Maybe b) -> ZipList a -> ZipList b

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

mapThese :: Functor ZipList => (a -> These l r) -> ZipList a -> (ZipList l, ZipList r)

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

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

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

bindMaybe :: Monad ZipList => (a -> ZipList (Maybe b)) -> ZipList a -> ZipList b

bindThese :: Monad ZipList => (a -> ZipList (These l r)) -> ZipList a -> (ZipList l, ZipList r)

traverseMaybe :: (Applicative g, Traversable ZipList) => (a -> g (Maybe b)) -> ZipList a -> g (ZipList b)

traverseThese :: (Applicative g, Traversable ZipList) => (a -> g (These l r)) -> ZipList a -> g (ZipList l, ZipList r)

Compactable STM

Defined in Control.Functor.Compactable

Methods

compact :: STM (Maybe a) -> STM a

separateThese :: STM (These l r) -> (STM l, STM r)

filter :: (a -> Bool) -> STM a -> STM a

partition :: (a -> Bool) -> STM a -> (STM a, STM a)

mapMaybe :: Functor STM => (a -> Maybe b) -> STM a -> STM b

contramapMaybe :: Contravariant STM => (Maybe b -> a) -> STM a -> STM b

mapThese :: Functor STM => (a -> These l r) -> STM a -> (STM l, STM r)

contramapThese :: Contravariant STM => (These l r -> a) -> STM a -> (STM l, STM r)

applyMaybe :: Applicative STM => STM (a -> Maybe b) -> STM a -> STM b

applyThese :: Applicative STM => STM (a -> These l r) -> STM a -> (STM l, STM r)

bindMaybe :: Monad STM => (a -> STM (Maybe b)) -> STM a -> STM b

bindThese :: Monad STM => (a -> STM (These l r)) -> STM a -> (STM l, STM r)

traverseMaybe :: (Applicative g, Traversable STM) => (a -> g (Maybe b)) -> STM a -> g (STM b)

traverseThese :: (Applicative g, Traversable STM) => (a -> g (These l r)) -> STM a -> g (STM l, STM r)

Compactable IntMap

Defined in Control.Functor.Compactable

Methods

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

separateThese :: IntMap (These l r) -> (IntMap l, IntMap r)

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

partition :: (a -> Bool) -> IntMap a -> (IntMap a, IntMap a)

mapMaybe :: Functor IntMap => (a -> Maybe b) -> IntMap a -> IntMap b

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

mapThese :: Functor IntMap => (a -> These l r) -> IntMap a -> (IntMap l, IntMap r)

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

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

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

bindMaybe :: Monad IntMap => (a -> IntMap (Maybe b)) -> IntMap a -> IntMap b

bindThese :: Monad IntMap => (a -> IntMap (These l r)) -> IntMap a -> (IntMap l, IntMap r)

traverseMaybe :: (Applicative g, Traversable IntMap) => (a -> g (Maybe b)) -> IntMap a -> g (IntMap b)

traverseThese :: (Applicative g, Traversable IntMap) => (a -> g (These l r)) -> IntMap a -> g (IntMap l, IntMap r)

Compactable Seq

Defined in Control.Functor.Compactable

Methods

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

separateThese :: Seq (These l r) -> (Seq l, Seq r)

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

partition :: (a -> Bool) -> Seq a -> (Seq a, Seq a)

mapMaybe :: Functor Seq => (a -> Maybe b) -> Seq a -> Seq b

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

mapThese :: Functor Seq => (a -> These l r) -> Seq a -> (Seq l, Seq r)

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

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

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

bindMaybe :: Monad Seq => (a -> Seq (Maybe b)) -> Seq a -> Seq b

bindThese :: Monad Seq => (a -> Seq (These l r)) -> Seq a -> (Seq l, Seq r)

traverseMaybe :: (Applicative g, Traversable Seq) => (a -> g (Maybe b)) -> Seq a -> g (Seq b)

traverseThese :: (Applicative g, Traversable Seq) => (a -> g (These l r)) -> Seq a -> g (Seq l, Seq r)

Compactable Set

Defined in Control.Functor.Compactable

Methods

compact :: Set (Maybe a) -> Set a

separateThese :: Set (These l r) -> (Set l, Set r)

filter :: (a -> Bool) -> Set a -> Set a

partition :: (a -> Bool) -> Set a -> (Set a, Set a)

mapMaybe :: Functor Set => (a -> Maybe b) -> Set a -> Set b

contramapMaybe :: Contravariant Set => (Maybe b -> a) -> Set a -> Set b

mapThese :: Functor Set => (a -> These l r) -> Set a -> (Set l, Set r)

contramapThese :: Contravariant Set => (These l r -> a) -> Set a -> (Set l, Set r)

applyMaybe :: Applicative Set => Set (a -> Maybe b) -> Set a -> Set b

applyThese :: Applicative Set => Set (a -> These l r) -> Set a -> (Set l, Set r)

bindMaybe :: Monad Set => (a -> Set (Maybe b)) -> Set a -> Set b

bindThese :: Monad Set => (a -> Set (These l r)) -> Set a -> (Set l, Set r)

traverseMaybe :: (Applicative g, Traversable Set) => (a -> g (Maybe b)) -> Set a -> g (Set b)

traverseThese :: (Applicative g, Traversable Set) => (a -> g (These l r)) -> Set a -> g (Set l, Set r)

Compactable Vector

Defined in Control.Functor.Compactable

Methods

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

separateThese :: Vector (These l r) -> (Vector l, Vector r)

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

partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

mapMaybe :: Functor Vector => (a -> Maybe b) -> Vector a -> Vector b

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

mapThese :: Functor Vector => (a -> These l r) -> Vector a -> (Vector l, Vector r)

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

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

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

bindMaybe :: Monad Vector => (a -> Vector (Maybe b)) -> Vector a -> Vector b

bindThese :: Monad Vector => (a -> Vector (These l r)) -> Vector a -> (Vector l, Vector r)

traverseMaybe :: (Applicative g, Traversable Vector) => (a -> g (Maybe b)) -> Vector a -> g (Vector b)

traverseThese :: (Applicative g, Traversable Vector) => (a -> g (These l r)) -> Vector a -> g (Vector l, Vector r)

Monoid m => Compactable (Either m)

Defined in Control.Functor.Compactable

Methods

compact :: Either m (Maybe a) -> Either m a

separateThese :: Either m (These l r) -> (Either m l, Either m r)

filter :: (a -> Bool) -> Either m a -> Either m a

partition :: (a -> Bool) -> Either m a -> (Either m a, Either m a)

mapMaybe :: Functor (Either m) => (a -> Maybe b) -> Either m a -> Either m b

contramapMaybe :: Contravariant (Either m) => (Maybe b -> a) -> Either m a -> Either m b

mapThese :: Functor (Either m) => (a -> These l r) -> Either m a -> (Either m l, Either m r)

contramapThese :: Contravariant (Either m) => (These l r -> a) -> Either m a -> (Either m l, Either m r)

applyMaybe :: Applicative (Either m) => Either m (a -> Maybe b) -> Either m a -> Either m b

applyThese :: Applicative (Either m) => Either m (a -> These l r) -> Either m a -> (Either m l, Either m r)

bindMaybe :: Monad (Either m) => (a -> Either m (Maybe b)) -> Either m a -> Either m b

bindThese :: Monad (Either m) => (a -> Either m (These l r)) -> Either m a -> (Either m l, Either m r)

traverseMaybe :: (Applicative g, Traversable (Either m)) => (a -> g (Maybe b)) -> Either m a -> g (Either m b)

traverseThese :: (Applicative g, Traversable (Either m)) => (a -> g (These l r)) -> Either m a -> g (Either m l, Either m r)

Compactable (U1 :: Type -> Type)

Defined in Control.Functor.Compactable

Methods

compact :: U1 (Maybe a) -> U1 a

separateThese :: U1 (These l r) -> (U1 l, U1 r)

filter :: (a -> Bool) -> U1 a -> U1 a

partition :: (a -> Bool) -> U1 a -> (U1 a, U1 a)

mapMaybe :: Functor U1 => (a -> Maybe b) -> U1 a -> U1 b

contramapMaybe :: Contravariant U1 => (Maybe b -> a) -> U1 a -> U1 b

mapThese :: Functor U1 => (a -> These l r) -> U1 a -> (U1 l, U1 r)

contramapThese :: Contravariant U1 => (These l r -> a) -> U1 a -> (U1 l, U1 r)

applyMaybe :: Applicative U1 => U1 (a -> Maybe b) -> U1 a -> U1 b

applyThese :: Applicative U1 => U1 (a -> These l r) -> U1 a -> (U1 l, U1 r)

bindMaybe :: Monad U1 => (a -> U1 (Maybe b)) -> U1 a -> U1 b

bindThese :: Monad U1 => (a -> U1 (These l r)) -> U1 a -> (U1 l, U1 r)

traverseMaybe :: (Applicative g, Traversable U1) => (a -> g (Maybe b)) -> U1 a -> g (U1 b)

traverseThese :: (Applicative g, Traversable U1) => (a -> g (These l r)) -> U1 a -> g (U1 l, U1 r)

Compactable (Map k)

Defined in Control.Functor.Compactable

Methods

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

separateThese :: Map k (These l r) -> (Map k l, Map k r)

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

partition :: (a -> Bool) -> Map k a -> (Map k a, Map k a)

mapMaybe :: Functor (Map k) => (a -> Maybe b) -> Map k a -> Map k b

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

mapThese :: Functor (Map k) => (a -> These l r) -> Map k a -> (Map k l, Map k r)

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

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

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

bindMaybe :: Monad (Map k) => (a -> Map k (Maybe b)) -> Map k a -> Map k b

bindThese :: Monad (Map k) => (a -> Map k (These l r)) -> Map k a -> (Map k l, Map k r)

traverseMaybe :: (Applicative g, Traversable (Map k)) => (a -> g (Maybe b)) -> Map k a -> g (Map k b)

traverseThese :: (Applicative g, Traversable (Map k)) => (a -> g (These l r)) -> Map k a -> g (Map k l, Map k r)

(Compactable a, Monad a) => Compactable (WrappedMonad a)

Defined in Control.Functor.Compactable

Methods

compact :: WrappedMonad a (Maybe a0) -> WrappedMonad a a0

separateThese :: WrappedMonad a (These l r) -> (WrappedMonad a l, WrappedMonad a r)

filter :: (a0 -> Bool) -> WrappedMonad a a0 -> WrappedMonad a a0

partition :: (a0 -> Bool) -> WrappedMonad a a0 -> (WrappedMonad a a0, WrappedMonad a a0)

mapMaybe :: Functor (WrappedMonad a) => (a0 -> Maybe b) -> WrappedMonad a a0 -> WrappedMonad a b

contramapMaybe :: Contravariant (WrappedMonad a) => (Maybe b -> a0) -> WrappedMonad a a0 -> WrappedMonad a b

mapThese :: Functor (WrappedMonad a) => (a0 -> These l r) -> WrappedMonad a a0 -> (WrappedMonad a l, WrappedMonad a r)

contramapThese :: Contravariant (WrappedMonad a) => (These l r -> a0) -> WrappedMonad a a0 -> (WrappedMonad a l, WrappedMonad a r)

applyMaybe :: Applicative (WrappedMonad a) => WrappedMonad a (a0 -> Maybe b) -> WrappedMonad a a0 -> WrappedMonad a b

applyThese :: Applicative (WrappedMonad a) => WrappedMonad a (a0 -> These l r) -> WrappedMonad a a0 -> (WrappedMonad a l, WrappedMonad a r)

bindMaybe :: Monad (WrappedMonad a) => (a0 -> WrappedMonad a (Maybe b)) -> WrappedMonad a a0 -> WrappedMonad a b

bindThese :: Monad (WrappedMonad a) => (a0 -> WrappedMonad a (These l r)) -> WrappedMonad a a0 -> (WrappedMonad a l, WrappedMonad a r)

traverseMaybe :: (Applicative g, Traversable (WrappedMonad a)) => (a0 -> g (Maybe b)) -> WrappedMonad a a0 -> g (WrappedMonad a b)

traverseThese :: (Applicative g, Traversable (WrappedMonad a)) => (a0 -> g (These l r)) -> WrappedMonad a a0 -> g (WrappedMonad a l, WrappedMonad a r)

Compactable (Proxy :: Type -> Type)

Defined in Control.Functor.Compactable

Methods

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

separateThese :: Proxy (These l r) -> (Proxy l, Proxy r)

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

partition :: (a -> Bool) -> Proxy a -> (Proxy a, Proxy a)

mapMaybe :: Functor Proxy => (a -> Maybe b) -> Proxy a -> Proxy b

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

mapThese :: Functor Proxy => (a -> These l r) -> Proxy a -> (Proxy l, Proxy r)

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

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

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

bindMaybe :: Monad Proxy => (a -> Proxy (Maybe b)) -> Proxy a -> Proxy b

bindThese :: Monad Proxy => (a -> Proxy (These l r)) -> Proxy a -> (Proxy l, Proxy r)

traverseMaybe :: (Applicative g, Traversable Proxy) => (a -> g (Maybe b)) -> Proxy a -> g (Proxy b)

traverseThese :: (Applicative g, Traversable Proxy) => (a -> g (These l r)) -> Proxy a -> g (Proxy l, Proxy r)

Monoid m => Compactable (These m)

Defined in Control.Functor.Compactable

Methods

compact :: These m (Maybe a) -> These m a

separateThese :: These m (These l r) -> (These m l, These m r)

filter :: (a -> Bool) -> These m a -> These m a

partition :: (a -> Bool) -> These m a -> (These m a, These m a)

mapMaybe :: Functor (These m) => (a -> Maybe b) -> These m a -> These m b

contramapMaybe :: Contravariant (These m) => (Maybe b -> a) -> These m a -> These m b

mapThese :: Functor (These m) => (a -> These l r) -> These m a -> (These m l, These m r)

contramapThese :: Contravariant (These m) => (These l r -> a) -> These m a -> (These m l, These m r)

applyMaybe :: Applicative (These m) => These m (a -> Maybe b) -> These m a -> These m b

applyThese :: Applicative (These m) => These m (a -> These l r) -> These m a -> (These m l, These m r)

bindMaybe :: Monad (These m) => (a -> These m (Maybe b)) -> These m a -> These m b

bindThese :: Monad (These m) => (a -> These m (These l r)) -> These m a -> (These m l, These m r)

traverseMaybe :: (Applicative g, Traversable (These m)) => (a -> g (Maybe b)) -> These m a -> g (These m b)

traverseThese :: (Applicative g, Traversable (These m)) => (a -> g (These l r)) -> These m a -> g (These m l, These m r)

(Compactable a, Functor a) => Compactable (Rec1 a)

Defined in Control.Functor.Compactable

Methods

compact :: Rec1 a (Maybe a0) -> Rec1 a a0

separateThese :: Rec1 a (These l r) -> (Rec1 a l, Rec1 a r)

filter :: (a0 -> Bool) -> Rec1 a a0 -> Rec1 a a0

partition :: (a0 -> Bool) -> Rec1 a a0 -> (Rec1 a a0, Rec1 a a0)

mapMaybe :: Functor (Rec1 a) => (a0 -> Maybe b) -> Rec1 a a0 -> Rec1 a b

contramapMaybe :: Contravariant (Rec1 a) => (Maybe b -> a0) -> Rec1 a a0 -> Rec1 a b

mapThese :: Functor (Rec1 a) => (a0 -> These l r) -> Rec1 a a0 -> (Rec1 a l, Rec1 a r)

contramapThese :: Contravariant (Rec1 a) => (These l r -> a0) -> Rec1 a a0 -> (Rec1 a l, Rec1 a r)

applyMaybe :: Applicative (Rec1 a) => Rec1 a (a0 -> Maybe b) -> Rec1 a a0 -> Rec1 a b

applyThese :: Applicative (Rec1 a) => Rec1 a (a0 -> These l r) -> Rec1 a a0 -> (Rec1 a l, Rec1 a r)

bindMaybe :: Monad (Rec1 a) => (a0 -> Rec1 a (Maybe b)) -> Rec1 a a0 -> Rec1 a b

bindThese :: Monad (Rec1 a) => (a0 -> Rec1 a (These l r)) -> Rec1 a a0 -> (Rec1 a l, Rec1 a r)

traverseMaybe :: (Applicative g, Traversable (Rec1 a)) => (a0 -> g (Maybe b)) -> Rec1 a a0 -> g (Rec1 a b)

traverseThese :: (Applicative g, Traversable (Rec1 a)) => (a0 -> g (These l r)) -> Rec1 a a0 -> g (Rec1 a l, Rec1 a r)

Compactable (Const r :: Type -> Type)

Defined in Control.Functor.Compactable

Methods

compact :: Const r (Maybe a) -> Const r a

separateThese :: Const r (These l r0) -> (Const r l, Const r r0)

filter :: (a -> Bool) -> Const r a -> Const r a

partition :: (a -> Bool) -> Const r a -> (Const r a, Const r a)

mapMaybe :: Functor (Const r) => (a -> Maybe b) -> Const r a -> Const r b

contramapMaybe :: Contravariant (Const r) => (Maybe b -> a) -> Const r a -> Const r b

mapThese :: Functor (Const r) => (a -> These l r0) -> Const r a -> (Const r l, Const r r0)

contramapThese :: Contravariant (Const r) => (These l r0 -> a) -> Const r a -> (Const r l, Const r r0)

applyMaybe :: Applicative (Const r) => Const r (a -> Maybe b) -> Const r a -> Const r b

applyThese :: Applicative (Const r) => Const r (a -> These l r0) -> Const r a -> (Const r l, Const r r0)

bindMaybe :: Monad (Const r) => (a -> Const r (Maybe b)) -> Const r a -> Const r b

bindThese :: Monad (Const r) => (a -> Const r (These l r0)) -> Const r a -> (Const r l, Const r r0)

traverseMaybe :: (Applicative g, Traversable (Const r)) => (a -> g (Maybe b)) -> Const r a -> g (Const r b)

traverseThese :: (Applicative g, Traversable (Const r)) => (a -> g (These l r0)) -> Const r a -> g (Const r l, Const r r0)

(Compactable a, Functor a) => Compactable (Alt a)

Defined in Control.Functor.Compactable

Methods

compact :: Alt a (Maybe a0) -> Alt a a0

separateThese :: Alt a (These l r) -> (Alt a l, Alt a r)

filter :: (a0 -> Bool) -> Alt a a0 -> Alt a a0

partition :: (a0 -> Bool) -> Alt a a0 -> (Alt a a0, Alt a a0)

mapMaybe :: Functor (Alt a) => (a0 -> Maybe b) -> Alt a a0 -> Alt a b

contramapMaybe :: Contravariant (Alt a) => (Maybe b -> a0) -> Alt a a0 -> Alt a b

mapThese :: Functor (Alt a) => (a0 -> These l r) -> Alt a a0 -> (Alt a l, Alt a r)

contramapThese :: Contravariant (Alt a) => (These l r -> a0) -> Alt a a0 -> (Alt a l, Alt a r)

applyMaybe :: Applicative (Alt a) => Alt a (a0 -> Maybe b) -> Alt a a0 -> Alt a b

applyThese :: Applicative (Alt a) => Alt a (a0 -> These l r) -> Alt a a0 -> (Alt a l, Alt a r)

bindMaybe :: Monad (Alt a) => (a0 -> Alt a (Maybe b)) -> Alt a a0 -> Alt a b

bindThese :: Monad (Alt a) => (a0 -> Alt a (These l r)) -> Alt a a0 -> (Alt a l, Alt a r)

traverseMaybe :: (Applicative g, Traversable (Alt a)) => (a0 -> g (Maybe b)) -> Alt a a0 -> g (Alt a b)

traverseThese :: (Applicative g, Traversable (Alt a)) => (a0 -> g (These l r)) -> Alt a a0 -> g (Alt a l, Alt a r)

(Compactable a, Functor a, Compactable b, Functor b) => Compactable (a :*: b)

Defined in Control.Functor.Compactable

Methods

compact :: (a :*: b) (Maybe a0) -> (a :*: b) a0

separateThese :: (a :*: b) (These l r) -> ((a :*: b) l, (a :*: b) r)

filter :: (a0 -> Bool) -> (a :*: b) a0 -> (a :*: b) a0

partition :: (a0 -> Bool) -> (a :*: b) a0 -> ((a :*: b) a0, (a :*: b) a0)

mapMaybe :: Functor (a :*: b) => (a0 -> Maybe b0) -> (a :*: b) a0 -> (a :*: b) b0

contramapMaybe :: Contravariant (a :*: b) => (Maybe b0 -> a0) -> (a :*: b) a0 -> (a :*: b) b0

mapThese :: Functor (a :*: b) => (a0 -> These l r) -> (a :*: b) a0 -> ((a :*: b) l, (a :*: b) r)

contramapThese :: Contravariant (a :*: b) => (These l r -> a0) -> (a :*: b) a0 -> ((a :*: b) l, (a :*: b) r)

applyMaybe :: Applicative (a :*: b) => (a :*: b) (a0 -> Maybe b0) -> (a :*: b) a0 -> (a :*: b) b0

applyThese :: Applicative (a :*: b) => (a :*: b) (a0 -> These l r) -> (a :*: b) a0 -> ((a :*: b) l, (a :*: b) r)

bindMaybe :: Monad (a :*: b) => (a0 -> (a :*: b) (Maybe b0)) -> (a :*: b) a0 -> (a :*: b) b0

bindThese :: Monad (a :*: b) => (a0 -> (a :*: b) (These l r)) -> (a :*: b) a0 -> ((a :*: b) l, (a :*: b) r)

traverseMaybe :: (Applicative g, Traversable (a :*: b)) => (a0 -> g (Maybe b0)) -> (a :*: b) a0 -> g ((a :*: b) b0)

traverseThese :: (Applicative g, Traversable (a :*: b)) => (a0 -> g (These l r)) -> (a :*: b) a0 -> g ((a :*: b) l, (a :*: b) r)

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

Defined in Control.Functor.Compactable

Methods

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

separateThese :: Product f g (These l r) -> (Product f g l, Product f g r)

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

partition :: (a -> Bool) -> Product f g a -> (Product f g a, Product f g a)

mapMaybe :: Functor (Product f g) => (a -> Maybe b) -> Product f g a -> Product f g b

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

mapThese :: Functor (Product f g) => (a -> These l r) -> Product f g a -> (Product f g l, Product f g r)

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

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

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

bindMaybe :: Monad (Product f g) => (a -> Product f g (Maybe b)) -> Product f g a -> Product f g b

bindThese :: Monad (Product f g) => (a -> Product f g (These l r)) -> Product f g a -> (Product f g l, Product f g r)

traverseMaybe :: (Applicative g0, Traversable (Product f g)) => (a -> g0 (Maybe b)) -> Product f g a -> g0 (Product f g b)

traverseThese :: (Applicative g0, Traversable (Product f g)) => (a -> g0 (These l r)) -> Product f g a -> g0 (Product f g l, Product f g r)

(Compactable f, Functor f) => Compactable (M1 i c f)

Defined in Control.Functor.Compactable

Methods

compact :: M1 i c f (Maybe a) -> M1 i c f a

separateThese :: M1 i c f (These l r) -> (M1 i c f l, M1 i c f r)

filter :: (a -> Bool) -> M1 i c f a -> M1 i c f a

partition :: (a -> Bool) -> M1 i c f a -> (M1 i c f a, M1 i c f a)

mapMaybe :: Functor (M1 i c f) => (a -> Maybe b) -> M1 i c f a -> M1 i c f b

contramapMaybe :: Contravariant (M1 i c f) => (Maybe b -> a) -> M1 i c f a -> M1 i c f b

mapThese :: Functor (M1 i c f) => (a -> These l r) -> M1 i c f a -> (M1 i c f l, M1 i c f r)

contramapThese :: Contravariant (M1 i c f) => (These l r -> a) -> M1 i c f a -> (M1 i c f l, M1 i c f r)

applyMaybe :: Applicative (M1 i c f) => M1 i c f (a -> Maybe b) -> M1 i c f a -> M1 i c f b

applyThese :: Applicative (M1 i c f) => M1 i c f (a -> These l r) -> M1 i c f a -> (M1 i c f l, M1 i c f r)

bindMaybe :: Monad (M1 i c f) => (a -> M1 i c f (Maybe b)) -> M1 i c f a -> M1 i c f b

bindThese :: Monad (M1 i c f) => (a -> M1 i c f (These l r)) -> M1 i c f a -> (M1 i c f l, M1 i c f r)

traverseMaybe :: (Applicative g, Traversable (M1 i c f)) => (a -> g (Maybe b)) -> M1 i c f a -> g (M1 i c f b)

traverseThese :: (Applicative g, Traversable (M1 i c f)) => (a -> g (These l r)) -> M1 i c f a -> g (M1 i c f l, M1 i c f r)

(Functor f, Compactable g, Functor g) => Compactable (f :.: g)

Defined in Control.Functor.Compactable

Methods

compact :: (f :.: g) (Maybe a) -> (f :.: g) a

separateThese :: (f :.: g) (These l r) -> ((f :.: g) l, (f :.: g) r)

filter :: (a -> Bool) -> (f :.: g) a -> (f :.: g) a

partition :: (a -> Bool) -> (f :.: g) a -> ((f :.: g) a, (f :.: g) a)

mapMaybe :: Functor (f :.: g) => (a -> Maybe b) -> (f :.: g) a -> (f :.: g) b

contramapMaybe :: Contravariant (f :.: g) => (Maybe b -> a) -> (f :.: g) a -> (f :.: g) b

mapThese :: Functor (f :.: g) => (a -> These l r) -> (f :.: g) a -> ((f :.: g) l, (f :.: g) r)

contramapThese :: Contravariant (f :.: g) => (These l r -> a) -> (f :.: g) a -> ((f :.: g) l, (f :.: g) r)

applyMaybe :: Applicative (f :.: g) => (f :.: g) (a -> Maybe b) -> (f :.: g) a -> (f :.: g) b

applyThese :: Applicative (f :.: g) => (f :.: g) (a -> These l r) -> (f :.: g) a -> ((f :.: g) l, (f :.: g) r)

bindMaybe :: Monad (f :.: g) => (a -> (f :.: g) (Maybe b)) -> (f :.: g) a -> (f :.: g) b

bindThese :: Monad (f :.: g) => (a -> (f :.: g) (These l r)) -> (f :.: g) a -> ((f :.: g) l, (f :.: g) r)

traverseMaybe :: (Applicative g0, Traversable (f :.: g)) => (a -> g0 (Maybe b)) -> (f :.: g) a -> g0 ((f :.: g) b)

traverseThese :: (Applicative g0, Traversable (f :.: g)) => (a -> g0 (These l r)) -> (f :.: g) a -> g0 ((f :.: g) l, (f :.: g) r)

(Functor f, Functor g, Compactable f, Compactable g) => Compactable (Compose f g)

Defined in Control.Functor.Compactable

Methods

compact :: Compose f g (Maybe a) -> Compose f g a

separateThese :: Compose f g (These l r) -> (Compose f g l, Compose f g r)

filter :: (a -> Bool) -> Compose f g a -> Compose f g a

partition :: (a -> Bool) -> Compose f g a -> (Compose f g a, Compose f g a)

mapMaybe :: Functor (Compose f g) => (a -> Maybe b) -> Compose f g a -> Compose f g b

contramapMaybe :: Contravariant (Compose f g) => (Maybe b -> a) -> Compose f g a -> Compose f g b

mapThese :: Functor (Compose f g) => (a -> These l r) -> Compose f g a -> (Compose f g l, Compose f g r)

contramapThese :: Contravariant (Compose f g) => (These l r -> a) -> Compose f g a -> (Compose f g l, Compose f g r)

applyMaybe :: Applicative (Compose f g) => Compose f g (a -> Maybe b) -> Compose f g a -> Compose f g b

applyThese :: Applicative (Compose f g) => Compose f g (a -> These l r) -> Compose f g a -> (Compose f g l, Compose f g r)

bindMaybe :: Monad (Compose f g) => (a -> Compose f g (Maybe b)) -> Compose f g a -> Compose f g b

bindThese :: Monad (Compose f g) => (a -> Compose f g (These l r)) -> Compose f g a -> (Compose f g l, Compose f g r)

traverseMaybe :: (Applicative g0, Traversable (Compose f g)) => (a -> g0 (Maybe b)) -> Compose f g a -> g0 (Compose f g b)

traverseThese :: (Applicative g0, Traversable (Compose f g)) => (a -> g0 (These l r)) -> Compose f g a -> g0 (Compose f g l, Compose f g r)

class (Compactable f, Expansive f) => Elastic f

Instances

Elastic Maybe

Defined in Control.Functor.Elastic

Elastic IntMap

Defined in Control.Functor.Elastic

Ord k => Elastic (Map k)

Defined in Control.Functor.Elastic