Safe Haskell	None
Language	Haskell2010

Control.Functor.Compactable

Contents

Compact
Handly flips
More general lefts and rights
Monad Transformer utils
Alternative Defaults

Synopsis

class Compactable (f :: Type -> Type) where
- compact :: f (Maybe a) -> f a
- separateThese :: f (These l r) -> (f l, f r)
- filter :: (a -> Bool) -> f a -> f a
- partition :: (a -> Bool) -> f a -> (f a, f a)
- mapMaybe :: Functor f => (a -> Maybe b) -> f a -> f b
- contramapMaybe :: Contravariant f => (Maybe b -> a) -> f a -> f b
- mapThese :: Functor f => (a -> These l r) -> f a -> (f l, f r)
- contramapThese :: Contravariant f => (These l r -> a) -> f a -> (f l, f r)
- applyMaybe :: Applicative f => f (a -> Maybe b) -> f a -> f b
- applyThese :: Applicative f => f (a -> These l r) -> f a -> (f l, f r)
- bindMaybe :: Monad f => (a -> f (Maybe b)) -> f a -> f b
- bindThese :: Monad f => (a -> f (These l r)) -> f a -> (f l, f r)
- traverseMaybe :: (Applicative g, Traversable f) => (a -> g (Maybe b)) -> f a -> g (f b)
- traverseThese :: (Applicative g, Traversable f) => (a -> g (These l r)) -> f a -> g (f l, f r)
separate :: (Dichotomous g, Functor f, Compactable f) => f (g l r) -> (f l, f r)
fforMaybe :: (Compactable f, Functor f) => f a -> (a -> Maybe b) -> f b
fforThese :: (Compactable f, Functor f) => f a -> (a -> These l r) -> (f l, f r)
mfold' :: (Foldable f, Alternative m) => f a -> m a
mlefts :: (Bifoldable f, Alternative m) => f a b -> m a
mrights :: (Bifoldable f, Alternative m) => f a b -> m b
mapMaybeM :: (Compactable f, Monad f) => (a -> MaybeT f b) -> f a -> f b
mapTheseM :: (Compactable f, Monad f) => (a -> ExceptT l f r) -> f a -> (f l, f r)
fforMaybeM :: (Compactable f, Monad f) => f a -> (a -> MaybeT f b) -> f b
fforTheseM :: (Compactable f, Monad f) => f a -> (a -> ExceptT l f r) -> (f l, f r)
applyMaybeM :: (Compactable f, Monad f) => f (a -> MaybeT f b) -> f a -> f b
bindMaybeM :: (Compactable f, Monad f) => f a -> (a -> f (MaybeT f b)) -> f b
traverseMaybeM :: (Monad m, Compactable t, Traversable t) => (a -> MaybeT m b) -> t a -> m (t b)
altDefaultCompact :: (Alternative f, Monad f) => f (Maybe a) -> f a
altDefaultSeparate :: (Dichotomous d, Alternative f, Foldable f) => f (d l r) -> (f l, f r)

Compact

class Compactable (f :: Type -> Type) where Source #

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

Methods

compact :: f (Maybe a) -> f a Source #

default compact :: Functor f => f (Maybe a) -> f a Source #

separateThese :: f (These l r) -> (f l, f r) Source #

default separateThese :: Functor f => f (These l r) -> (f l, f r) Source #

filter :: (a -> Bool) -> f a -> f a Source #

default filter :: Functor f => (a -> Bool) -> f a -> f a Source #

partition :: (a -> Bool) -> f a -> (f a, f a) Source #

default partition :: Functor f => (a -> Bool) -> f a -> (f a, f a) Source #

mapMaybe :: Functor f => (a -> Maybe b) -> f a -> f b Source #

contramapMaybe :: Contravariant f => (Maybe b -> a) -> f a -> f b Source #

mapThese :: Functor f => (a -> These l r) -> f a -> (f l, f r) Source #

contramapThese :: Contravariant f => (These l r -> a) -> f a -> (f l, f r) Source #

applyMaybe :: Applicative f => f (a -> Maybe b) -> f a -> f b Source #

applyThese :: Applicative f => f (a -> These l r) -> f a -> (f l, f r) Source #

bindMaybe :: Monad f => (a -> f (Maybe b)) -> f a -> f b Source #

bindThese :: Monad f => (a -> f (These l r)) -> f a -> (f l, f r) Source #

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

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

Instances

Instances details

Compactable [] Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: [Maybe a] -> [a] Source # separateThese :: [These l r] -> ([l], [r]) Source # filter :: (a -> Bool) -> [a] -> [a] Source # partition :: (a -> Bool) -> [a] -> ([a], [a]) Source # mapMaybe :: Functor [] => (a -> Maybe b) -> [a] -> [b] Source # contramapMaybe :: Contravariant [] => (Maybe b -> a) -> [a] -> [b] Source # mapThese :: Functor [] => (a -> These l r) -> [a] -> ([l], [r]) Source # contramapThese :: Contravariant [] => (These l r -> a) -> [a] -> ([l], [r]) Source # applyMaybe :: Applicative [] => [a -> Maybe b] -> [a] -> [b] Source # applyThese :: Applicative [] => [a -> These l r] -> [a] -> ([l], [r]) Source # bindMaybe :: Monad [] => (a -> [Maybe b]) -> [a] -> [b] Source # bindThese :: Monad [] => (a -> [These l r]) -> [a] -> ([l], [r]) Source # traverseMaybe :: (Applicative g, Traversable []) => (a -> g (Maybe b)) -> [a] -> g [b] Source # traverseThese :: (Applicative g, Traversable []) => (a -> g (These l r)) -> [a] -> g ([l], [r]) Source #
Compactable Maybe Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Maybe (Maybe a) -> Maybe a Source # separateThese :: Maybe (These l r) -> (Maybe l, Maybe r) Source # filter :: (a -> Bool) -> Maybe a -> Maybe a Source # partition :: (a -> Bool) -> Maybe a -> (Maybe a, Maybe a) Source # mapMaybe :: Functor Maybe => (a -> Maybe b) -> Maybe a -> Maybe b Source # contramapMaybe :: Contravariant Maybe => (Maybe b -> a) -> Maybe a -> Maybe b Source # mapThese :: Functor Maybe => (a -> These l r) -> Maybe a -> (Maybe l, Maybe r) Source # contramapThese :: Contravariant Maybe => (These l r -> a) -> Maybe a -> (Maybe l, Maybe r) Source # applyMaybe :: Applicative Maybe => Maybe (a -> Maybe b) -> Maybe a -> Maybe b Source # applyThese :: Applicative Maybe => Maybe (a -> These l r) -> Maybe a -> (Maybe l, Maybe r) Source # bindMaybe :: Monad Maybe => (a -> Maybe (Maybe b)) -> Maybe a -> Maybe b Source # bindThese :: Monad Maybe => (a -> Maybe (These l r)) -> Maybe a -> (Maybe l, Maybe r) Source # traverseMaybe :: (Applicative g, Traversable Maybe) => (a -> g (Maybe b)) -> Maybe a -> g (Maybe b) Source # traverseThese :: (Applicative g, Traversable Maybe) => (a -> g (These l r)) -> Maybe a -> g (Maybe l, Maybe r) Source #
Compactable IO Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: IO (Maybe a) -> IO a Source # separateThese :: IO (These l r) -> (IO l, IO r) Source # filter :: (a -> Bool) -> IO a -> IO a Source # partition :: (a -> Bool) -> IO a -> (IO a, IO a) Source # mapMaybe :: Functor IO => (a -> Maybe b) -> IO a -> IO b Source # contramapMaybe :: Contravariant IO => (Maybe b -> a) -> IO a -> IO b Source # mapThese :: Functor IO => (a -> These l r) -> IO a -> (IO l, IO r) Source # contramapThese :: Contravariant IO => (These l r -> a) -> IO a -> (IO l, IO r) Source # applyMaybe :: Applicative IO => IO (a -> Maybe b) -> IO a -> IO b Source # applyThese :: Applicative IO => IO (a -> These l r) -> IO a -> (IO l, IO r) Source # bindMaybe :: Monad IO => (a -> IO (Maybe b)) -> IO a -> IO b Source # bindThese :: Monad IO => (a -> IO (These l r)) -> IO a -> (IO l, IO r) Source # traverseMaybe :: (Applicative g, Traversable IO) => (a -> g (Maybe b)) -> IO a -> g (IO b) Source # traverseThese :: (Applicative g, Traversable IO) => (a -> g (These l r)) -> IO a -> g (IO l, IO r) Source #
Compactable Option Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Option (Maybe a) -> Option a Source # separateThese :: Option (These l r) -> (Option l, Option r) Source # filter :: (a -> Bool) -> Option a -> Option a Source # partition :: (a -> Bool) -> Option a -> (Option a, Option a) Source # mapMaybe :: Functor Option => (a -> Maybe b) -> Option a -> Option b Source # contramapMaybe :: Contravariant Option => (Maybe b -> a) -> Option a -> Option b Source # mapThese :: Functor Option => (a -> These l r) -> Option a -> (Option l, Option r) Source # contramapThese :: Contravariant Option => (These l r -> a) -> Option a -> (Option l, Option r) Source # applyMaybe :: Applicative Option => Option (a -> Maybe b) -> Option a -> Option b Source # applyThese :: Applicative Option => Option (a -> These l r) -> Option a -> (Option l, Option r) Source # bindMaybe :: Monad Option => (a -> Option (Maybe b)) -> Option a -> Option b Source # bindThese :: Monad Option => (a -> Option (These l r)) -> Option a -> (Option l, Option r) Source # traverseMaybe :: (Applicative g, Traversable Option) => (a -> g (Maybe b)) -> Option a -> g (Option b) Source # traverseThese :: (Applicative g, Traversable Option) => (a -> g (These l r)) -> Option a -> g (Option l, Option r) Source #
Compactable ZipList Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: ZipList (Maybe a) -> ZipList a Source # separateThese :: ZipList (These l r) -> (ZipList l, ZipList r) Source # filter :: (a -> Bool) -> ZipList a -> ZipList a Source # partition :: (a -> Bool) -> ZipList a -> (ZipList a, ZipList a) Source # mapMaybe :: Functor ZipList => (a -> Maybe b) -> ZipList a -> ZipList b Source # contramapMaybe :: Contravariant ZipList => (Maybe b -> a) -> ZipList a -> ZipList b Source # mapThese :: Functor ZipList => (a -> These l r) -> ZipList a -> (ZipList l, ZipList r) Source # contramapThese :: Contravariant ZipList => (These l r -> a) -> ZipList a -> (ZipList l, ZipList r) Source # applyMaybe :: Applicative ZipList => ZipList (a -> Maybe b) -> ZipList a -> ZipList b Source # applyThese :: Applicative ZipList => ZipList (a -> These l r) -> ZipList a -> (ZipList l, ZipList r) Source # bindMaybe :: Monad ZipList => (a -> ZipList (Maybe b)) -> ZipList a -> ZipList b Source # bindThese :: Monad ZipList => (a -> ZipList (These l r)) -> ZipList a -> (ZipList l, ZipList r) Source # traverseMaybe :: (Applicative g, Traversable ZipList) => (a -> g (Maybe b)) -> ZipList a -> g (ZipList b) Source # traverseThese :: (Applicative g, Traversable ZipList) => (a -> g (These l r)) -> ZipList a -> g (ZipList l, ZipList r) Source #
Compactable STM Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: STM (Maybe a) -> STM a Source # separateThese :: STM (These l r) -> (STM l, STM r) Source # filter :: (a -> Bool) -> STM a -> STM a Source # partition :: (a -> Bool) -> STM a -> (STM a, STM a) Source # mapMaybe :: Functor STM => (a -> Maybe b) -> STM a -> STM b Source # contramapMaybe :: Contravariant STM => (Maybe b -> a) -> STM a -> STM b Source # mapThese :: Functor STM => (a -> These l r) -> STM a -> (STM l, STM r) Source # contramapThese :: Contravariant STM => (These l r -> a) -> STM a -> (STM l, STM r) Source # applyMaybe :: Applicative STM => STM (a -> Maybe b) -> STM a -> STM b Source # applyThese :: Applicative STM => STM (a -> These l r) -> STM a -> (STM l, STM r) Source # bindMaybe :: Monad STM => (a -> STM (Maybe b)) -> STM a -> STM b Source # bindThese :: Monad STM => (a -> STM (These l r)) -> STM a -> (STM l, STM r) Source # traverseMaybe :: (Applicative g, Traversable STM) => (a -> g (Maybe b)) -> STM a -> g (STM b) Source # traverseThese :: (Applicative g, Traversable STM) => (a -> g (These l r)) -> STM a -> g (STM l, STM r) Source #
Compactable IntMap Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: IntMap (Maybe a) -> IntMap a Source # separateThese :: IntMap (These l r) -> (IntMap l, IntMap r) Source # filter :: (a -> Bool) -> IntMap a -> IntMap a Source # partition :: (a -> Bool) -> IntMap a -> (IntMap a, IntMap a) Source # mapMaybe :: Functor IntMap => (a -> Maybe b) -> IntMap a -> IntMap b Source # contramapMaybe :: Contravariant IntMap => (Maybe b -> a) -> IntMap a -> IntMap b Source # mapThese :: Functor IntMap => (a -> These l r) -> IntMap a -> (IntMap l, IntMap r) Source # contramapThese :: Contravariant IntMap => (These l r -> a) -> IntMap a -> (IntMap l, IntMap r) Source # applyMaybe :: Applicative IntMap => IntMap (a -> Maybe b) -> IntMap a -> IntMap b Source # applyThese :: Applicative IntMap => IntMap (a -> These l r) -> IntMap a -> (IntMap l, IntMap r) Source # bindMaybe :: Monad IntMap => (a -> IntMap (Maybe b)) -> IntMap a -> IntMap b Source # bindThese :: Monad IntMap => (a -> IntMap (These l r)) -> IntMap a -> (IntMap l, IntMap r) Source # traverseMaybe :: (Applicative g, Traversable IntMap) => (a -> g (Maybe b)) -> IntMap a -> g (IntMap b) Source # traverseThese :: (Applicative g, Traversable IntMap) => (a -> g (These l r)) -> IntMap a -> g (IntMap l, IntMap r) Source #
Compactable Seq Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Seq (Maybe a) -> Seq a Source # separateThese :: Seq (These l r) -> (Seq l, Seq r) Source # filter :: (a -> Bool) -> Seq a -> Seq a Source # partition :: (a -> Bool) -> Seq a -> (Seq a, Seq a) Source # mapMaybe :: Functor Seq => (a -> Maybe b) -> Seq a -> Seq b Source # contramapMaybe :: Contravariant Seq => (Maybe b -> a) -> Seq a -> Seq b Source # mapThese :: Functor Seq => (a -> These l r) -> Seq a -> (Seq l, Seq r) Source # contramapThese :: Contravariant Seq => (These l r -> a) -> Seq a -> (Seq l, Seq r) Source # applyMaybe :: Applicative Seq => Seq (a -> Maybe b) -> Seq a -> Seq b Source # applyThese :: Applicative Seq => Seq (a -> These l r) -> Seq a -> (Seq l, Seq r) Source # bindMaybe :: Monad Seq => (a -> Seq (Maybe b)) -> Seq a -> Seq b Source # bindThese :: Monad Seq => (a -> Seq (These l r)) -> Seq a -> (Seq l, Seq r) Source # traverseMaybe :: (Applicative g, Traversable Seq) => (a -> g (Maybe b)) -> Seq a -> g (Seq b) Source # traverseThese :: (Applicative g, Traversable Seq) => (a -> g (These l r)) -> Seq a -> g (Seq l, Seq r) Source #
Compactable Set Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Set (Maybe a) -> Set a Source # separateThese :: Set (These l r) -> (Set l, Set r) Source # filter :: (a -> Bool) -> Set a -> Set a Source # partition :: (a -> Bool) -> Set a -> (Set a, Set a) Source # mapMaybe :: Functor Set => (a -> Maybe b) -> Set a -> Set b Source # contramapMaybe :: Contravariant Set => (Maybe b -> a) -> Set a -> Set b Source # mapThese :: Functor Set => (a -> These l r) -> Set a -> (Set l, Set r) Source # contramapThese :: Contravariant Set => (These l r -> a) -> Set a -> (Set l, Set r) Source # applyMaybe :: Applicative Set => Set (a -> Maybe b) -> Set a -> Set b Source # applyThese :: Applicative Set => Set (a -> These l r) -> Set a -> (Set l, Set r) Source # bindMaybe :: Monad Set => (a -> Set (Maybe b)) -> Set a -> Set b Source # bindThese :: Monad Set => (a -> Set (These l r)) -> Set a -> (Set l, Set r) Source # traverseMaybe :: (Applicative g, Traversable Set) => (a -> g (Maybe b)) -> Set a -> g (Set b) Source # traverseThese :: (Applicative g, Traversable Set) => (a -> g (These l r)) -> Set a -> g (Set l, Set r) Source #
Compactable Vector Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Vector (Maybe a) -> Vector a Source # separateThese :: Vector (These l r) -> (Vector l, Vector r) Source # filter :: (a -> Bool) -> Vector a -> Vector a Source # partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a) Source # mapMaybe :: Functor Vector => (a -> Maybe b) -> Vector a -> Vector b Source # contramapMaybe :: Contravariant Vector => (Maybe b -> a) -> Vector a -> Vector b Source # mapThese :: Functor Vector => (a -> These l r) -> Vector a -> (Vector l, Vector r) Source # contramapThese :: Contravariant Vector => (These l r -> a) -> Vector a -> (Vector l, Vector r) Source # applyMaybe :: Applicative Vector => Vector (a -> Maybe b) -> Vector a -> Vector b Source # applyThese :: Applicative Vector => Vector (a -> These l r) -> Vector a -> (Vector l, Vector r) Source # bindMaybe :: Monad Vector => (a -> Vector (Maybe b)) -> Vector a -> Vector b Source # bindThese :: Monad Vector => (a -> Vector (These l r)) -> Vector a -> (Vector l, Vector r) Source # traverseMaybe :: (Applicative g, Traversable Vector) => (a -> g (Maybe b)) -> Vector a -> g (Vector b) Source # traverseThese :: (Applicative g, Traversable Vector) => (a -> g (These l r)) -> Vector a -> g (Vector l, Vector r) Source #
Monoid m => Compactable (Either m) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Either m (Maybe a) -> Either m a Source # separateThese :: Either m (These l r) -> (Either m l, Either m r) Source # filter :: (a -> Bool) -> Either m a -> Either m a Source # partition :: (a -> Bool) -> Either m a -> (Either m a, Either m a) Source # mapMaybe :: Functor (Either m) => (a -> Maybe b) -> Either m a -> Either m b Source # contramapMaybe :: Contravariant (Either m) => (Maybe b -> a) -> Either m a -> Either m b Source # mapThese :: Functor (Either m) => (a -> These l r) -> Either m a -> (Either m l, Either m r) Source # contramapThese :: Contravariant (Either m) => (These l r -> a) -> Either m a -> (Either m l, Either m r) Source # applyMaybe :: Applicative (Either m) => Either m (a -> Maybe b) -> Either m a -> Either m b Source # applyThese :: Applicative (Either m) => Either m (a -> These l r) -> Either m a -> (Either m l, Either m r) Source # bindMaybe :: Monad (Either m) => (a -> Either m (Maybe b)) -> Either m a -> Either m b Source # bindThese :: Monad (Either m) => (a -> Either m (These l r)) -> Either m a -> (Either m l, Either m r) Source # traverseMaybe :: (Applicative g, Traversable (Either m)) => (a -> g (Maybe b)) -> Either m a -> g (Either m b) Source # traverseThese :: (Applicative g, Traversable (Either m)) => (a -> g (These l r)) -> Either m a -> g (Either m l, Either m r) Source #
Compactable (U1 :: Type -> Type) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: U1 (Maybe a) -> U1 a Source # separateThese :: U1 (These l r) -> (U1 l, U1 r) Source # filter :: (a -> Bool) -> U1 a -> U1 a Source # partition :: (a -> Bool) -> U1 a -> (U1 a, U1 a) Source # mapMaybe :: Functor U1 => (a -> Maybe b) -> U1 a -> U1 b Source # contramapMaybe :: Contravariant U1 => (Maybe b -> a) -> U1 a -> U1 b Source # mapThese :: Functor U1 => (a -> These l r) -> U1 a -> (U1 l, U1 r) Source # contramapThese :: Contravariant U1 => (These l r -> a) -> U1 a -> (U1 l, U1 r) Source # applyMaybe :: Applicative U1 => U1 (a -> Maybe b) -> U1 a -> U1 b Source # applyThese :: Applicative U1 => U1 (a -> These l r) -> U1 a -> (U1 l, U1 r) Source # bindMaybe :: Monad U1 => (a -> U1 (Maybe b)) -> U1 a -> U1 b Source # bindThese :: Monad U1 => (a -> U1 (These l r)) -> U1 a -> (U1 l, U1 r) Source # traverseMaybe :: (Applicative g, Traversable U1) => (a -> g (Maybe b)) -> U1 a -> g (U1 b) Source # traverseThese :: (Applicative g, Traversable U1) => (a -> g (These l r)) -> U1 a -> g (U1 l, U1 r) Source #
Compactable (Map k) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Map k (Maybe a) -> Map k a Source # separateThese :: Map k (These l r) -> (Map k l, Map k r) Source # filter :: (a -> Bool) -> Map k a -> Map k a Source # partition :: (a -> Bool) -> Map k a -> (Map k a, Map k a) Source # mapMaybe :: Functor (Map k) => (a -> Maybe b) -> Map k a -> Map k b Source # contramapMaybe :: Contravariant (Map k) => (Maybe b -> a) -> Map k a -> Map k b Source # mapThese :: Functor (Map k) => (a -> These l r) -> Map k a -> (Map k l, Map k r) Source # contramapThese :: Contravariant (Map k) => (These l r -> a) -> Map k a -> (Map k l, Map k r) Source # applyMaybe :: Applicative (Map k) => Map k (a -> Maybe b) -> Map k a -> Map k b Source # applyThese :: Applicative (Map k) => Map k (a -> These l r) -> Map k a -> (Map k l, Map k r) Source # bindMaybe :: Monad (Map k) => (a -> Map k (Maybe b)) -> Map k a -> Map k b Source # bindThese :: Monad (Map k) => (a -> Map k (These l r)) -> Map k a -> (Map k l, Map k r) Source # traverseMaybe :: (Applicative g, Traversable (Map k)) => (a -> g (Maybe b)) -> Map k a -> g (Map k b) Source # traverseThese :: (Applicative g, Traversable (Map k)) => (a -> g (These l r)) -> Map k a -> g (Map k l, Map k r) Source #
(Compactable a, Monad a) => Compactable (WrappedMonad a) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: WrappedMonad a (Maybe a0) -> WrappedMonad a a0 Source # separateThese :: WrappedMonad a (These l r) -> (WrappedMonad a l, WrappedMonad a r) Source # filter :: (a0 -> Bool) -> WrappedMonad a a0 -> WrappedMonad a a0 Source # partition :: (a0 -> Bool) -> WrappedMonad a a0 -> (WrappedMonad a a0, WrappedMonad a a0) Source # mapMaybe :: Functor (WrappedMonad a) => (a0 -> Maybe b) -> WrappedMonad a a0 -> WrappedMonad a b Source # contramapMaybe :: Contravariant (WrappedMonad a) => (Maybe b -> a0) -> WrappedMonad a a0 -> WrappedMonad a b Source # mapThese :: Functor (WrappedMonad a) => (a0 -> These l r) -> WrappedMonad a a0 -> (WrappedMonad a l, WrappedMonad a r) Source # contramapThese :: Contravariant (WrappedMonad a) => (These l r -> a0) -> WrappedMonad a a0 -> (WrappedMonad a l, WrappedMonad a r) Source # applyMaybe :: Applicative (WrappedMonad a) => WrappedMonad a (a0 -> Maybe b) -> WrappedMonad a a0 -> WrappedMonad a b Source # applyThese :: Applicative (WrappedMonad a) => WrappedMonad a (a0 -> These l r) -> WrappedMonad a a0 -> (WrappedMonad a l, WrappedMonad a r) Source # bindMaybe :: Monad (WrappedMonad a) => (a0 -> WrappedMonad a (Maybe b)) -> WrappedMonad a a0 -> WrappedMonad a b Source # bindThese :: Monad (WrappedMonad a) => (a0 -> WrappedMonad a (These l r)) -> WrappedMonad a a0 -> (WrappedMonad a l, WrappedMonad a r) Source # traverseMaybe :: (Applicative g, Traversable (WrappedMonad a)) => (a0 -> g (Maybe b)) -> WrappedMonad a a0 -> g (WrappedMonad a b) Source # traverseThese :: (Applicative g, Traversable (WrappedMonad a)) => (a0 -> g (These l r)) -> WrappedMonad a a0 -> g (WrappedMonad a l, WrappedMonad a r) Source #
Compactable (Proxy :: Type -> Type) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Proxy (Maybe a) -> Proxy a Source # separateThese :: Proxy (These l r) -> (Proxy l, Proxy r) Source # filter :: (a -> Bool) -> Proxy a -> Proxy a Source # partition :: (a -> Bool) -> Proxy a -> (Proxy a, Proxy a) Source # mapMaybe :: Functor Proxy => (a -> Maybe b) -> Proxy a -> Proxy b Source # contramapMaybe :: Contravariant Proxy => (Maybe b -> a) -> Proxy a -> Proxy b Source # mapThese :: Functor Proxy => (a -> These l r) -> Proxy a -> (Proxy l, Proxy r) Source # contramapThese :: Contravariant Proxy => (These l r -> a) -> Proxy a -> (Proxy l, Proxy r) Source # applyMaybe :: Applicative Proxy => Proxy (a -> Maybe b) -> Proxy a -> Proxy b Source # applyThese :: Applicative Proxy => Proxy (a -> These l r) -> Proxy a -> (Proxy l, Proxy r) Source # bindMaybe :: Monad Proxy => (a -> Proxy (Maybe b)) -> Proxy a -> Proxy b Source # bindThese :: Monad Proxy => (a -> Proxy (These l r)) -> Proxy a -> (Proxy l, Proxy r) Source # traverseMaybe :: (Applicative g, Traversable Proxy) => (a -> g (Maybe b)) -> Proxy a -> g (Proxy b) Source # traverseThese :: (Applicative g, Traversable Proxy) => (a -> g (These l r)) -> Proxy a -> g (Proxy l, Proxy r) Source #
Monoid m => Compactable (These m) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: These m (Maybe a) -> These m a Source # separateThese :: These m (These l r) -> (These m l, These m r) Source # filter :: (a -> Bool) -> These m a -> These m a Source # partition :: (a -> Bool) -> These m a -> (These m a, These m a) Source # mapMaybe :: Functor (These m) => (a -> Maybe b) -> These m a -> These m b Source # contramapMaybe :: Contravariant (These m) => (Maybe b -> a) -> These m a -> These m b Source # mapThese :: Functor (These m) => (a -> These l r) -> These m a -> (These m l, These m r) Source # contramapThese :: Contravariant (These m) => (These l r -> a) -> These m a -> (These m l, These m r) Source # applyMaybe :: Applicative (These m) => These m (a -> Maybe b) -> These m a -> These m b Source # applyThese :: Applicative (These m) => These m (a -> These l r) -> These m a -> (These m l, These m r) Source # bindMaybe :: Monad (These m) => (a -> These m (Maybe b)) -> These m a -> These m b Source # bindThese :: Monad (These m) => (a -> These m (These l r)) -> These m a -> (These m l, These m r) Source # traverseMaybe :: (Applicative g, Traversable (These m)) => (a -> g (Maybe b)) -> These m a -> g (These m b) Source # traverseThese :: (Applicative g, Traversable (These m)) => (a -> g (These l r)) -> These m a -> g (These m l, These m r) Source #
(Compactable a, Functor a) => Compactable (Rec1 a) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Rec1 a (Maybe a0) -> Rec1 a a0 Source # separateThese :: Rec1 a (These l r) -> (Rec1 a l, Rec1 a r) Source # filter :: (a0 -> Bool) -> Rec1 a a0 -> Rec1 a a0 Source # partition :: (a0 -> Bool) -> Rec1 a a0 -> (Rec1 a a0, Rec1 a a0) Source # mapMaybe :: Functor (Rec1 a) => (a0 -> Maybe b) -> Rec1 a a0 -> Rec1 a b Source # contramapMaybe :: Contravariant (Rec1 a) => (Maybe b -> a0) -> Rec1 a a0 -> Rec1 a b Source # mapThese :: Functor (Rec1 a) => (a0 -> These l r) -> Rec1 a a0 -> (Rec1 a l, Rec1 a r) Source # contramapThese :: Contravariant (Rec1 a) => (These l r -> a0) -> Rec1 a a0 -> (Rec1 a l, Rec1 a r) Source # applyMaybe :: Applicative (Rec1 a) => Rec1 a (a0 -> Maybe b) -> Rec1 a a0 -> Rec1 a b Source # applyThese :: Applicative (Rec1 a) => Rec1 a (a0 -> These l r) -> Rec1 a a0 -> (Rec1 a l, Rec1 a r) Source # bindMaybe :: Monad (Rec1 a) => (a0 -> Rec1 a (Maybe b)) -> Rec1 a a0 -> Rec1 a b Source # bindThese :: Monad (Rec1 a) => (a0 -> Rec1 a (These l r)) -> Rec1 a a0 -> (Rec1 a l, Rec1 a r) Source # traverseMaybe :: (Applicative g, Traversable (Rec1 a)) => (a0 -> g (Maybe b)) -> Rec1 a a0 -> g (Rec1 a b) Source # traverseThese :: (Applicative g, Traversable (Rec1 a)) => (a0 -> g (These l r)) -> Rec1 a a0 -> g (Rec1 a l, Rec1 a r) Source #
Compactable (Const r :: Type -> Type) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Const r (Maybe a) -> Const r a Source # separateThese :: Const r (These l r0) -> (Const r l, Const r r0) Source # filter :: (a -> Bool) -> Const r a -> Const r a Source # partition :: (a -> Bool) -> Const r a -> (Const r a, Const r a) Source # mapMaybe :: Functor (Const r) => (a -> Maybe b) -> Const r a -> Const r b Source # contramapMaybe :: Contravariant (Const r) => (Maybe b -> a) -> Const r a -> Const r b Source # mapThese :: Functor (Const r) => (a -> These l r0) -> Const r a -> (Const r l, Const r r0) Source # contramapThese :: Contravariant (Const r) => (These l r0 -> a) -> Const r a -> (Const r l, Const r r0) Source # applyMaybe :: Applicative (Const r) => Const r (a -> Maybe b) -> Const r a -> Const r b Source # applyThese :: Applicative (Const r) => Const r (a -> These l r0) -> Const r a -> (Const r l, Const r r0) Source # bindMaybe :: Monad (Const r) => (a -> Const r (Maybe b)) -> Const r a -> Const r b Source # bindThese :: Monad (Const r) => (a -> Const r (These l r0)) -> Const r a -> (Const r l, Const r r0) Source # traverseMaybe :: (Applicative g, Traversable (Const r)) => (a -> g (Maybe b)) -> Const r a -> g (Const r b) Source # traverseThese :: (Applicative g, Traversable (Const r)) => (a -> g (These l r0)) -> Const r a -> g (Const r l, Const r r0) Source #
(Compactable a, Functor a) => Compactable (Alt a) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Alt a (Maybe a0) -> Alt a a0 Source # separateThese :: Alt a (These l r) -> (Alt a l, Alt a r) Source # filter :: (a0 -> Bool) -> Alt a a0 -> Alt a a0 Source # partition :: (a0 -> Bool) -> Alt a a0 -> (Alt a a0, Alt a a0) Source # mapMaybe :: Functor (Alt a) => (a0 -> Maybe b) -> Alt a a0 -> Alt a b Source # contramapMaybe :: Contravariant (Alt a) => (Maybe b -> a0) -> Alt a a0 -> Alt a b Source # mapThese :: Functor (Alt a) => (a0 -> These l r) -> Alt a a0 -> (Alt a l, Alt a r) Source # contramapThese :: Contravariant (Alt a) => (These l r -> a0) -> Alt a a0 -> (Alt a l, Alt a r) Source # applyMaybe :: Applicative (Alt a) => Alt a (a0 -> Maybe b) -> Alt a a0 -> Alt a b Source # applyThese :: Applicative (Alt a) => Alt a (a0 -> These l r) -> Alt a a0 -> (Alt a l, Alt a r) Source # bindMaybe :: Monad (Alt a) => (a0 -> Alt a (Maybe b)) -> Alt a a0 -> Alt a b Source # bindThese :: Monad (Alt a) => (a0 -> Alt a (These l r)) -> Alt a a0 -> (Alt a l, Alt a r) Source # traverseMaybe :: (Applicative g, Traversable (Alt a)) => (a0 -> g (Maybe b)) -> Alt a a0 -> g (Alt a b) Source # traverseThese :: (Applicative g, Traversable (Alt a)) => (a0 -> g (These l r)) -> Alt a a0 -> g (Alt a l, Alt a r) Source #
(Compactable a, Functor a, Compactable b, Functor b) => Compactable (a :*: b) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: (a :: b) (Maybe a0) -> (a :: b) a0 Source # separateThese :: (a :: b) (These l r) -> ((a :: b) l, (a :: b) r) Source # filter :: (a0 -> Bool) -> (a :: b) a0 -> (a :: b) a0 Source # partition :: (a0 -> Bool) -> (a :: b) a0 -> ((a :: b) a0, (a :: b) a0) Source # mapMaybe :: Functor (a :: b) => (a0 -> Maybe b0) -> (a :: b) a0 -> (a :: b) b0 Source # contramapMaybe :: Contravariant (a :: b) => (Maybe b0 -> a0) -> (a :: b) a0 -> (a :: b) b0 Source # mapThese :: Functor (a :: b) => (a0 -> These l r) -> (a :: b) a0 -> ((a :: b) l, (a :: b) r) Source # contramapThese :: Contravariant (a :: b) => (These l r -> a0) -> (a :: b) a0 -> ((a :: b) l, (a :: b) r) Source # applyMaybe :: Applicative (a :: b) => (a :: b) (a0 -> Maybe b0) -> (a :: b) a0 -> (a :: b) b0 Source # applyThese :: Applicative (a :: b) => (a :: b) (a0 -> These l r) -> (a :: b) a0 -> ((a :: b) l, (a :: b) r) Source # bindMaybe :: Monad (a :: b) => (a0 -> (a :: b) (Maybe b0)) -> (a :: b) a0 -> (a :: b) b0 Source # bindThese :: Monad (a :: b) => (a0 -> (a :: b) (These l r)) -> (a :: b) a0 -> ((a :: b) l, (a :: b) r) Source # traverseMaybe :: (Applicative g, Traversable (a :: b)) => (a0 -> g (Maybe b0)) -> (a :: b) a0 -> g ((a :: b) b0) Source # traverseThese :: (Applicative g, Traversable (a :: b)) => (a0 -> g (These l r)) -> (a :: b) a0 -> g ((a :: b) l, (a :*: b) r) Source #
(Functor f, Functor g, Compactable f, Compactable g) => Compactable (Product f g) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Product f g (Maybe a) -> Product f g a Source # separateThese :: Product f g (These l r) -> (Product f g l, Product f g r) Source # filter :: (a -> Bool) -> Product f g a -> Product f g a Source # partition :: (a -> Bool) -> Product f g a -> (Product f g a, Product f g a) Source # mapMaybe :: Functor (Product f g) => (a -> Maybe b) -> Product f g a -> Product f g b Source # contramapMaybe :: Contravariant (Product f g) => (Maybe b -> a) -> Product f g a -> Product f g b Source # mapThese :: Functor (Product f g) => (a -> These l r) -> Product f g a -> (Product f g l, Product f g r) Source # contramapThese :: Contravariant (Product f g) => (These l r -> a) -> Product f g a -> (Product f g l, Product f g r) Source # applyMaybe :: Applicative (Product f g) => Product f g (a -> Maybe b) -> Product f g a -> Product f g b Source # applyThese :: Applicative (Product f g) => Product f g (a -> These l r) -> Product f g a -> (Product f g l, Product f g r) Source # bindMaybe :: Monad (Product f g) => (a -> Product f g (Maybe b)) -> Product f g a -> Product f g b Source # bindThese :: Monad (Product f g) => (a -> Product f g (These l r)) -> Product f g a -> (Product f g l, Product f g r) Source # traverseMaybe :: (Applicative g0, Traversable (Product f g)) => (a -> g0 (Maybe b)) -> Product f g a -> g0 (Product f g b) Source # 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) Source #
(Compactable f, Functor f) => Compactable (M1 i c f) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: M1 i c f (Maybe a) -> M1 i c f a Source # separateThese :: M1 i c f (These l r) -> (M1 i c f l, M1 i c f r) Source # filter :: (a -> Bool) -> M1 i c f a -> M1 i c f a Source # partition :: (a -> Bool) -> M1 i c f a -> (M1 i c f a, M1 i c f a) Source # mapMaybe :: Functor (M1 i c f) => (a -> Maybe b) -> M1 i c f a -> M1 i c f b Source # contramapMaybe :: Contravariant (M1 i c f) => (Maybe b -> a) -> M1 i c f a -> M1 i c f b Source # 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) Source # 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) Source # applyMaybe :: Applicative (M1 i c f) => M1 i c f (a -> Maybe b) -> M1 i c f a -> M1 i c f b Source # 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) Source # bindMaybe :: Monad (M1 i c f) => (a -> M1 i c f (Maybe b)) -> M1 i c f a -> M1 i c f b Source # 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) Source # traverseMaybe :: (Applicative g, Traversable (M1 i c f)) => (a -> g (Maybe b)) -> M1 i c f a -> g (M1 i c f b) Source # 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) Source #
(Functor f, Compactable g, Functor g) => Compactable (f :.: g) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: (f :.: g) (Maybe a) -> (f :.: g) a Source # separateThese :: (f :.: g) (These l r) -> ((f :.: g) l, (f :.: g) r) Source # filter :: (a -> Bool) -> (f :.: g) a -> (f :.: g) a Source # partition :: (a -> Bool) -> (f :.: g) a -> ((f :.: g) a, (f :.: g) a) Source # mapMaybe :: Functor (f :.: g) => (a -> Maybe b) -> (f :.: g) a -> (f :.: g) b Source # contramapMaybe :: Contravariant (f :.: g) => (Maybe b -> a) -> (f :.: g) a -> (f :.: g) b Source # mapThese :: Functor (f :.: g) => (a -> These l r) -> (f :.: g) a -> ((f :.: g) l, (f :.: g) r) Source # contramapThese :: Contravariant (f :.: g) => (These l r -> a) -> (f :.: g) a -> ((f :.: g) l, (f :.: g) r) Source # applyMaybe :: Applicative (f :.: g) => (f :.: g) (a -> Maybe b) -> (f :.: g) a -> (f :.: g) b Source # applyThese :: Applicative (f :.: g) => (f :.: g) (a -> These l r) -> (f :.: g) a -> ((f :.: g) l, (f :.: g) r) Source # bindMaybe :: Monad (f :.: g) => (a -> (f :.: g) (Maybe b)) -> (f :.: g) a -> (f :.: g) b Source # bindThese :: Monad (f :.: g) => (a -> (f :.: g) (These l r)) -> (f :.: g) a -> ((f :.: g) l, (f :.: g) r) Source # traverseMaybe :: (Applicative g0, Traversable (f :.: g)) => (a -> g0 (Maybe b)) -> (f :.: g) a -> g0 ((f :.: g) b) Source # traverseThese :: (Applicative g0, Traversable (f :.: g)) => (a -> g0 (These l r)) -> (f :.: g) a -> g0 ((f :.: g) l, (f :.: g) r) Source #
(Functor f, Functor g, Compactable f, Compactable g) => Compactable (Compose f g) Source #
Instance details Defined in Control.Functor.Compactable Methods compact :: Compose f g (Maybe a) -> Compose f g a Source # separateThese :: Compose f g (These l r) -> (Compose f g l, Compose f g r) Source # filter :: (a -> Bool) -> Compose f g a -> Compose f g a Source # partition :: (a -> Bool) -> Compose f g a -> (Compose f g a, Compose f g a) Source # mapMaybe :: Functor (Compose f g) => (a -> Maybe b) -> Compose f g a -> Compose f g b Source # contramapMaybe :: Contravariant (Compose f g) => (Maybe b -> a) -> Compose f g a -> Compose f g b Source # mapThese :: Functor (Compose f g) => (a -> These l r) -> Compose f g a -> (Compose f g l, Compose f g r) Source # contramapThese :: Contravariant (Compose f g) => (These l r -> a) -> Compose f g a -> (Compose f g l, Compose f g r) Source # applyMaybe :: Applicative (Compose f g) => Compose f g (a -> Maybe b) -> Compose f g a -> Compose f g b Source # applyThese :: Applicative (Compose f g) => Compose f g (a -> These l r) -> Compose f g a -> (Compose f g l, Compose f g r) Source # bindMaybe :: Monad (Compose f g) => (a -> Compose f g (Maybe b)) -> Compose f g a -> Compose f g b Source # bindThese :: Monad (Compose f g) => (a -> Compose f g (These l r)) -> Compose f g a -> (Compose f g l, Compose f g r) Source # traverseMaybe :: (Applicative g0, Traversable (Compose f g)) => (a -> g0 (Maybe b)) -> Compose f g a -> g0 (Compose f g b) Source # 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) Source #

separate :: (Dichotomous g, Functor f, Compactable f) => f (g l r) -> (f l, f r) Source #

Handly flips

fforMaybe :: (Compactable f, Functor f) => f a -> (a -> Maybe b) -> f b Source #

fforThese :: (Compactable f, Functor f) => f a -> (a -> These l r) -> (f l, f r) Source #

More general lefts and rights

mfold' :: (Foldable f, Alternative m) => f a -> m a Source #

mlefts :: (Bifoldable f, Alternative m) => f a b -> m a Source #

mrights :: (Bifoldable f, Alternative m) => f a b -> m b Source #

Monad Transformer utils

mapMaybeM :: (Compactable f, Monad f) => (a -> MaybeT f b) -> f a -> f b Source #

mapTheseM :: (Compactable f, Monad f) => (a -> ExceptT l f r) -> f a -> (f l, f r) Source #

fforMaybeM :: (Compactable f, Monad f) => f a -> (a -> MaybeT f b) -> f b Source #

fforTheseM :: (Compactable f, Monad f) => f a -> (a -> ExceptT l f r) -> (f l, f r) Source #

applyMaybeM :: (Compactable f, Monad f) => f (a -> MaybeT f b) -> f a -> f b Source #

bindMaybeM :: (Compactable f, Monad f) => f a -> (a -> f (MaybeT f b)) -> f b Source #

traverseMaybeM :: (Monad m, Compactable t, Traversable t) => (a -> MaybeT m b) -> t a -> m (t b) Source #

Alternative Defaults

altDefaultCompact :: (Alternative f, Monad f) => f (Maybe a) -> f a Source #

While more constrained, when available, this default is going to be faster than the one provided in the typeclass

altDefaultSeparate :: (Dichotomous d, Alternative f, Foldable f) => f (d l r) -> (f l, f r) Source #

While more constrained, when available, this default is going to be faster than the one provided in the typeclass