Copyright	(c) Fumiaki Kinoshita 2015
License	BSD3
Maintainer	Fumiaki Kinoshita <fumiexcel@gmail.com>
Stability	provisional
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Data.Witherable

Contents

Indexed variants
Generalization
Cloning
Wrapper
Orphan instances

Description

Synopsis

class Functor f => Filterable (f :: Type -> Type) where
- mapMaybe :: (a -> Maybe b) -> f a -> f b
- catMaybes :: f (Maybe a) -> f a
- filter :: (a -> Bool) -> f a -> f a
(<$?>) :: Filterable f => (a -> Maybe b) -> f a -> f b
(<&?>) :: Filterable f => f a -> (a -> Maybe b) -> f b
class (Traversable t, Filterable t) => Witherable (t :: Type -> Type) where
- wither :: Applicative f => (a -> f (Maybe b)) -> t a -> f (t b)
- witherM :: Monad m => (a -> m (Maybe b)) -> t a -> m (t b)
- filterA :: Applicative f => (a -> f Bool) -> t a -> f (t a)
ordNub :: (Witherable t, Ord a) => t a -> t a
hashNub :: (Witherable t, Eq a, Hashable a) => t a -> t a
forMaybe :: (Witherable t, Applicative f) => t a -> (a -> f (Maybe b)) -> f (t b)
class (FunctorWithIndex i t, Filterable t) => FilterableWithIndex i t | t -> i where
- imapMaybe :: (i -> a -> Maybe b) -> t a -> t b
- ifilter :: (i -> a -> Bool) -> t a -> t a
class (TraversableWithIndex i t, Witherable t) => WitherableWithIndex i t | t -> i where
- iwither :: Applicative f => (i -> a -> f (Maybe b)) -> t a -> f (t b)
- iwitherM :: Monad m => (i -> a -> m (Maybe b)) -> t a -> m (t b)
- ifilterA :: Applicative f => (i -> a -> f Bool) -> t a -> f (t a)
type WitherLike f s t a b = (a -> f (Maybe b)) -> s -> f t
type Wither s t a b = forall f. Applicative f => WitherLike f s t a b
type WitherLike' f s a = WitherLike f s s a a
type Wither' s a = forall f. Applicative f => WitherLike' f s a
type FilterLike f s t a b = WitherLike f s t a b
type Filter s t a b = Wither s t a b
type FilterLike' f s a = WitherLike' f s a
type Filter' s a = Wither' s a
witherOf :: FilterLike f s t a b -> (a -> f (Maybe b)) -> s -> f t
forMaybeOf :: FilterLike f s t a b -> s -> (a -> f (Maybe b)) -> f t
mapMaybeOf :: FilterLike Identity s t a b -> (a -> Maybe b) -> s -> t
catMaybesOf :: FilterLike Identity s t (Maybe a) a -> s -> t
filterAOf :: Functor f => FilterLike' f s a -> (a -> f Bool) -> s -> f s
filterOf :: FilterLike' Identity s a -> (a -> Bool) -> s -> s
ordNubOf :: Ord a => FilterLike' (State (Set a)) s a -> s -> s
hashNubOf :: (Eq a, Hashable a) => FilterLike' (State (HashSet a)) s a -> s -> s
cloneFilter :: FilterLike (Peat a b) s t a b -> Filter s t a b
newtype Peat a b t = Peat {
- runPeat :: forall f. Applicative f => (a -> f (Maybe b)) -> f t
}
newtype WrappedFoldable f a = WrapFilterable {
- unwrapFoldable :: f a
}

Documentation

class Functor f => Filterable (f :: Type -> Type) where #

Like Functor, but you can remove elements instead of updating them.

Formally, the class Filterable represents a functor from Kleisli Maybe to Hask.

A definition of mapMaybe must satisfy the following laws:

conservation: mapMaybe (Just . f) ≡ fmap f
composition: mapMaybe f . mapMaybe g ≡ mapMaybe (f <=< g)

Minimal complete definition

mapMaybe | catMaybes

Methods

mapMaybe :: (a -> Maybe b) -> f a -> f b #

Like mapMaybe.

catMaybes :: f (Maybe a) -> f a #

catMaybes ≡ mapMaybe id

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

filter f . filter g ≡ filter (liftA2 (&&) f g)

Instances

Filterable []
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> [a] -> [b] # catMaybes :: [Maybe a] -> [a] # filter :: (a -> Bool) -> [a] -> [a] #
Filterable Maybe
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Maybe a -> Maybe b # catMaybes :: Maybe (Maybe a) -> Maybe a # filter :: (a -> Bool) -> Maybe a -> Maybe a #
Filterable Option
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Option a -> Option b # catMaybes :: Option (Maybe a) -> Option a # filter :: (a -> Bool) -> Option a -> Option a #
Filterable ZipList
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> ZipList a -> ZipList b # catMaybes :: ZipList (Maybe a) -> ZipList a # filter :: (a -> Bool) -> ZipList a -> ZipList a #
Filterable IntMap
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> IntMap a -> IntMap b # catMaybes :: IntMap (Maybe a) -> IntMap a # filter :: (a -> Bool) -> IntMap a -> IntMap a #
Filterable Seq
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Seq a -> Seq b # catMaybes :: Seq (Maybe a) -> Seq a # filter :: (a -> Bool) -> Seq a -> Seq a #
Filterable Vector
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Vector a -> Vector b # catMaybes :: Vector (Maybe a) -> Vector a # filter :: (a -> Bool) -> Vector a -> Vector a #
Monoid e => Filterable (Either e)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Either e a -> Either e b # catMaybes :: Either e (Maybe a) -> Either e a # filter :: (a -> Bool) -> Either e a -> Either e a #
Filterable (V1 :: Type -> Type)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> V1 a -> V1 b # catMaybes :: V1 (Maybe a) -> V1 a # filter :: (a -> Bool) -> V1 a -> V1 a #
Filterable (U1 :: Type -> Type)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> U1 a -> U1 b # catMaybes :: U1 (Maybe a) -> U1 a # filter :: (a -> Bool) -> U1 a -> U1 a #
(Eq k, Hashable k) => Filterable (HashMap k)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> HashMap k a -> HashMap k b # catMaybes :: HashMap k (Maybe a) -> HashMap k a # filter :: (a -> Bool) -> HashMap k a -> HashMap k a #
Filterable (Map k)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b # catMaybes :: Map k (Maybe a) -> Map k a # filter :: (a -> Bool) -> Map k a -> Map k a #
Filterable (Proxy :: Type -> Type)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Proxy a -> Proxy b # catMaybes :: Proxy (Maybe a) -> Proxy a # filter :: (a -> Bool) -> Proxy a -> Proxy a #
Functor f => Filterable (MaybeT f)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> MaybeT f a -> MaybeT f b # catMaybes :: MaybeT f (Maybe a) -> MaybeT f a # filter :: (a -> Bool) -> MaybeT f a -> MaybeT f a #
Filterable (MonoidalMap k) Source #
Instance details Defined in Data.Witherable Methods mapMaybe :: (a -> Maybe b) -> MonoidalMap k a -> MonoidalMap k b # catMaybes :: MonoidalMap k (Maybe a) -> MonoidalMap k a # filter :: (a -> Bool) -> MonoidalMap k a -> MonoidalMap k a #
(Foldable f, Alternative f) => Filterable (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods mapMaybe :: (a -> Maybe b) -> WrappedFoldable f a -> WrappedFoldable f b # catMaybes :: WrappedFoldable f (Maybe a) -> WrappedFoldable f a # filter :: (a -> Bool) -> WrappedFoldable f a -> WrappedFoldable f a #
Filterable f => Filterable (Rec1 f)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Rec1 f a -> Rec1 f b # catMaybes :: Rec1 f (Maybe a) -> Rec1 f a # filter :: (a -> Bool) -> Rec1 f a -> Rec1 f a #
Filterable (Const r :: Type -> Type)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Const r a -> Const r b # catMaybes :: Const r (Maybe a) -> Const r a # filter :: (a -> Bool) -> Const r a -> Const r a #
Filterable f => Filterable (IdentityT f)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> IdentityT f a -> IdentityT f b # catMaybes :: IdentityT f (Maybe a) -> IdentityT f a # filter :: (a -> Bool) -> IdentityT f a -> IdentityT f a #
Filterable t => Filterable (Backwards t)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Backwards t a -> Backwards t b # catMaybes :: Backwards t (Maybe a) -> Backwards t a # filter :: (a -> Bool) -> Backwards t a -> Backwards t a #
Filterable t => Filterable (Reverse t)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Reverse t a -> Reverse t b # catMaybes :: Reverse t (Maybe a) -> Reverse t a # filter :: (a -> Bool) -> Reverse t a -> Reverse t a #
(Filterable f, Filterable g) => Filterable (f :+: g)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> (f :+: g) a -> (f :+: g) b # catMaybes :: (f :+: g) (Maybe a) -> (f :+: g) a # filter :: (a -> Bool) -> (f :+: g) a -> (f :+: g) a #
(Filterable f, Filterable g) => Filterable (f :*: g)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> (f :: g) a -> (f :: g) b # catMaybes :: (f :: g) (Maybe a) -> (f :: g) a # filter :: (a -> Bool) -> (f :: g) a -> (f :: g) a #
(Filterable f, Filterable g) => Filterable (Product f g)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Product f g a -> Product f g b # catMaybes :: Product f g (Maybe a) -> Product f g a # filter :: (a -> Bool) -> Product f g a -> Product f g a #
(Filterable f, Filterable g) => Filterable (Sum f g)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Sum f g a -> Sum f g b # catMaybes :: Sum f g (Maybe a) -> Sum f g a # filter :: (a -> Bool) -> Sum f g a -> Sum f g a #
Filterable f => Filterable (M1 i c f)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> M1 i c f a -> M1 i c f b # catMaybes :: M1 i c f (Maybe a) -> M1 i c f a # filter :: (a -> Bool) -> M1 i c f a -> M1 i c f a #
(Functor f, Filterable g) => Filterable (f :.: g)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> (f :.: g) a -> (f :.: g) b # catMaybes :: (f :.: g) (Maybe a) -> (f :.: g) a # filter :: (a -> Bool) -> (f :.: g) a -> (f :.: g) a #
(Functor f, Filterable g) => Filterable (Compose f g)
Instance details Defined in Data.Witherable.Class Methods mapMaybe :: (a -> Maybe b) -> Compose f g a -> Compose f g b # catMaybes :: Compose f g (Maybe a) -> Compose f g a # filter :: (a -> Bool) -> Compose f g a -> Compose f g a #

(<$?>) :: Filterable f => (a -> Maybe b) -> f a -> f b infixl 4 Source #

An infix alias for mapMaybe. The name of the operator alludes to <$>, and has the same fixity.

Since: 0.3.1

(<&?>) :: Filterable f => f a -> (a -> Maybe b) -> f b infixl 1 Source #

Flipped version of <$?>, the Filterable version of <&>. It has the same fixity as <&>.

(<&?>) = flip mapMaybe

Since: 0.3.1

class (Traversable t, Filterable t) => Witherable (t :: Type -> Type) where #

An enhancement of Traversable with Filterable

A definition of wither must satisfy the following laws:

conservation: wither (fmap Just . f) ≡ traverse f
composition: Compose . fmap (wither f) . wither g ≡ wither (Compose . fmap (wither f) . g)

Parametricity implies the naturality law:

t . wither f ≡ wither (t . f)

Minimal complete definition

Nothing

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> t a -> f (t b) #

Effectful mapMaybe.

wither (pure . f) ≡ pure . mapMaybe f

witherM :: Monad m => (a -> m (Maybe b)) -> t a -> m (t b) #

Monadic variant of wither. This may have more efficient implementation.

filterA :: Applicative f => (a -> f Bool) -> t a -> f (t a) #

Instances

Witherable []	Methods are good consumers for fusion.
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> [a] -> f [b] # witherM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] # filterA :: Applicative f => (a -> f Bool) -> [a] -> f [a] #
Witherable Maybe
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Maybe a -> f (Maybe b) # witherM :: Monad m => (a -> m (Maybe b)) -> Maybe a -> m (Maybe b) # filterA :: Applicative f => (a -> f Bool) -> Maybe a -> f (Maybe a) #
Witherable Option
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Option a -> f (Option b) # witherM :: Monad m => (a -> m (Maybe b)) -> Option a -> m (Option b) # filterA :: Applicative f => (a -> f Bool) -> Option a -> f (Option a) #
Witherable ZipList
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> ZipList a -> f (ZipList b) # witherM :: Monad m => (a -> m (Maybe b)) -> ZipList a -> m (ZipList b) # filterA :: Applicative f => (a -> f Bool) -> ZipList a -> f (ZipList a) #
Witherable IntMap
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> IntMap a -> f (IntMap b) # witherM :: Monad m => (a -> m (Maybe b)) -> IntMap a -> m (IntMap b) # filterA :: Applicative f => (a -> f Bool) -> IntMap a -> f (IntMap a) #
Witherable Seq
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Seq a -> f (Seq b) # witherM :: Monad m => (a -> m (Maybe b)) -> Seq a -> m (Seq b) # filterA :: Applicative f => (a -> f Bool) -> Seq a -> f (Seq a) #
Witherable Vector
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Vector a -> f (Vector b) # witherM :: Monad m => (a -> m (Maybe b)) -> Vector a -> m (Vector b) # filterA :: Applicative f => (a -> f Bool) -> Vector a -> f (Vector a) #
Monoid e => Witherable (Either e)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Either e a -> f (Either e b) # witherM :: Monad m => (a -> m (Maybe b)) -> Either e a -> m (Either e b) # filterA :: Applicative f => (a -> f Bool) -> Either e a -> f (Either e a) #
Witherable (V1 :: Type -> Type)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> V1 a -> f (V1 b) # witherM :: Monad m => (a -> m (Maybe b)) -> V1 a -> m (V1 b) # filterA :: Applicative f => (a -> f Bool) -> V1 a -> f (V1 a) #
Witherable (U1 :: Type -> Type)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> U1 a -> f (U1 b) # witherM :: Monad m => (a -> m (Maybe b)) -> U1 a -> m (U1 b) # filterA :: Applicative f => (a -> f Bool) -> U1 a -> f (U1 a) #
(Eq k, Hashable k) => Witherable (HashMap k)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> HashMap k a -> f (HashMap k b) # witherM :: Monad m => (a -> m (Maybe b)) -> HashMap k a -> m (HashMap k b) # filterA :: Applicative f => (a -> f Bool) -> HashMap k a -> f (HashMap k a) #
Witherable (Map k)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Map k a -> f (Map k b) # witherM :: Monad m => (a -> m (Maybe b)) -> Map k a -> m (Map k b) # filterA :: Applicative f => (a -> f Bool) -> Map k a -> f (Map k a) #
Witherable (Proxy :: Type -> Type)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Proxy a -> f (Proxy b) # witherM :: Monad m => (a -> m (Maybe b)) -> Proxy a -> m (Proxy b) # filterA :: Applicative f => (a -> f Bool) -> Proxy a -> f (Proxy a) #
Traversable t => Witherable (MaybeT t)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> MaybeT t a -> f (MaybeT t b) # witherM :: Monad m => (a -> m (Maybe b)) -> MaybeT t a -> m (MaybeT t b) # filterA :: Applicative f => (a -> f Bool) -> MaybeT t a -> f (MaybeT t a) #
Witherable (MonoidalMap k) Source #
Instance details Defined in Data.Witherable Methods wither :: Applicative f => (a -> f (Maybe b)) -> MonoidalMap k a -> f (MonoidalMap k b) # witherM :: Monad m => (a -> m (Maybe b)) -> MonoidalMap k a -> m (MonoidalMap k b) # filterA :: Applicative f => (a -> f Bool) -> MonoidalMap k a -> f (MonoidalMap k a) #
(Alternative f, Traversable f) => Witherable (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> WrappedFoldable f a -> f0 (WrappedFoldable f b) # witherM :: Monad m => (a -> m (Maybe b)) -> WrappedFoldable f a -> m (WrappedFoldable f b) # filterA :: Applicative f0 => (a -> f0 Bool) -> WrappedFoldable f a -> f0 (WrappedFoldable f a) #
Witherable f => Witherable (Rec1 f)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> Rec1 f a -> f0 (Rec1 f b) # witherM :: Monad m => (a -> m (Maybe b)) -> Rec1 f a -> m (Rec1 f b) # filterA :: Applicative f0 => (a -> f0 Bool) -> Rec1 f a -> f0 (Rec1 f a) #
Witherable (Const r :: Type -> Type)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Const r a -> f (Const r b) # witherM :: Monad m => (a -> m (Maybe b)) -> Const r a -> m (Const r b) # filterA :: Applicative f => (a -> f Bool) -> Const r a -> f (Const r a) #
Witherable f => Witherable (IdentityT f)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> IdentityT f a -> f0 (IdentityT f b) # witherM :: Monad m => (a -> m (Maybe b)) -> IdentityT f a -> m (IdentityT f b) # filterA :: Applicative f0 => (a -> f0 Bool) -> IdentityT f a -> f0 (IdentityT f a) #
Witherable t => Witherable (Backwards t)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Backwards t a -> f (Backwards t b) # witherM :: Monad m => (a -> m (Maybe b)) -> Backwards t a -> m (Backwards t b) # filterA :: Applicative f => (a -> f Bool) -> Backwards t a -> f (Backwards t a) #
Witherable t => Witherable (Reverse t)	Wither from right to left.
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f => (a -> f (Maybe b)) -> Reverse t a -> f (Reverse t b) # witherM :: Monad m => (a -> m (Maybe b)) -> Reverse t a -> m (Reverse t b) # filterA :: Applicative f => (a -> f Bool) -> Reverse t a -> f (Reverse t a) #
(Witherable f, Witherable g) => Witherable (f :+: g)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> (f :+: g) a -> f0 ((f :+: g) b) # witherM :: Monad m => (a -> m (Maybe b)) -> (f :+: g) a -> m ((f :+: g) b) # filterA :: Applicative f0 => (a -> f0 Bool) -> (f :+: g) a -> f0 ((f :+: g) a) #
(Witherable f, Witherable g) => Witherable (f :*: g)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> (f :: g) a -> f0 ((f :: g) b) # witherM :: Monad m => (a -> m (Maybe b)) -> (f :: g) a -> m ((f :: g) b) # filterA :: Applicative f0 => (a -> f0 Bool) -> (f :: g) a -> f0 ((f :: g) a) #
(Witherable f, Witherable g) => Witherable (Product f g)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> Product f g a -> f0 (Product f g b) # witherM :: Monad m => (a -> m (Maybe b)) -> Product f g a -> m (Product f g b) # filterA :: Applicative f0 => (a -> f0 Bool) -> Product f g a -> f0 (Product f g a) #
(Witherable f, Witherable g) => Witherable (Sum f g)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> Sum f g a -> f0 (Sum f g b) # witherM :: Monad m => (a -> m (Maybe b)) -> Sum f g a -> m (Sum f g b) # filterA :: Applicative f0 => (a -> f0 Bool) -> Sum f g a -> f0 (Sum f g a) #
Witherable f => Witherable (M1 i c f)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> M1 i c f a -> f0 (M1 i c f b) # witherM :: Monad m => (a -> m (Maybe b)) -> M1 i c f a -> m (M1 i c f b) # filterA :: Applicative f0 => (a -> f0 Bool) -> M1 i c f a -> f0 (M1 i c f a) #
(Traversable f, Witherable g) => Witherable (f :.: g)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> (f :.: g) a -> f0 ((f :.: g) b) # witherM :: Monad m => (a -> m (Maybe b)) -> (f :.: g) a -> m ((f :.: g) b) # filterA :: Applicative f0 => (a -> f0 Bool) -> (f :.: g) a -> f0 ((f :.: g) a) #
(Traversable f, Witherable g) => Witherable (Compose f g)
Instance details Defined in Data.Witherable.Class Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> Compose f g a -> f0 (Compose f g b) # witherM :: Monad m => (a -> m (Maybe b)) -> Compose f g a -> m (Compose f g b) # filterA :: Applicative f0 => (a -> f0 Bool) -> Compose f g a -> f0 (Compose f g a) #

ordNub :: (Witherable t, Ord a) => t a -> t a Source #

Removes duplicate elements from a list, keeping only the first occurrence. This is asymptotically faster than using nub from Data.List.

hashNub :: (Witherable t, Eq a, Hashable a) => t a -> t a Source #

Removes duplicate elements from a list, keeping only the first occurrence. This is usually faster than ordNub, especially for things that have a slow comparison (like String).

forMaybe :: (Witherable t, Applicative f) => t a -> (a -> f (Maybe b)) -> f (t b) Source #

forMaybe = flip wither

Indexed variants

class (FunctorWithIndex i t, Filterable t) => FilterableWithIndex i t | t -> i where Source #

Indexed variant of Filterable.

Minimal complete definition

Nothing

Methods

imapMaybe :: (i -> a -> Maybe b) -> t a -> t b Source #

ifilter :: (i -> a -> Bool) -> t a -> t a Source #

ifilter f . ifilter g ≡ ifilter (i -> liftA2 (&&) (f i) (g i))

Instances

FilterableWithIndex Int [] Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (Int -> a -> Maybe b) -> [a] -> [b] Source # ifilter :: (Int -> a -> Bool) -> [a] -> [a] Source #
FilterableWithIndex Int ZipList Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (Int -> a -> Maybe b) -> ZipList a -> ZipList b Source # ifilter :: (Int -> a -> Bool) -> ZipList a -> ZipList a Source #
FilterableWithIndex Int IntMap Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (Int -> a -> Maybe b) -> IntMap a -> IntMap b Source # ifilter :: (Int -> a -> Bool) -> IntMap a -> IntMap a Source #
FilterableWithIndex Int Seq Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (Int -> a -> Maybe b) -> Seq a -> Seq b Source # ifilter :: (Int -> a -> Bool) -> Seq a -> Seq a Source #
FilterableWithIndex Int Vector Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (Int -> a -> Maybe b) -> Vector a -> Vector b Source # ifilter :: (Int -> a -> Bool) -> Vector a -> Vector a Source #
FilterableWithIndex () Maybe Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (() -> a -> Maybe b) -> Maybe a -> Maybe b Source # ifilter :: (() -> a -> Bool) -> Maybe a -> Maybe a Source #
(Eq k, Hashable k) => FilterableWithIndex k (HashMap k) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (k -> a -> Maybe b) -> HashMap k a -> HashMap k b Source # ifilter :: (k -> a -> Bool) -> HashMap k a -> HashMap k a Source #
FilterableWithIndex k (MonoidalMap k) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (k -> a -> Maybe b) -> MonoidalMap k a -> MonoidalMap k b Source # ifilter :: (k -> a -> Bool) -> MonoidalMap k a -> MonoidalMap k a Source #
FilterableWithIndex k (Map k) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (k -> a -> Maybe b) -> Map k a -> Map k b Source # ifilter :: (k -> a -> Bool) -> Map k a -> Map k a Source #
(FunctorWithIndex i f, FoldableWithIndex i f, Alternative f) => FilterableWithIndex i (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (i -> a -> Maybe b) -> WrappedFoldable f a -> WrappedFoldable f b Source # ifilter :: (i -> a -> Bool) -> WrappedFoldable f a -> WrappedFoldable f a Source #
FilterableWithIndex Void (Proxy :: Type -> Type) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (Void -> a -> Maybe b) -> Proxy a -> Proxy b Source # ifilter :: (Void -> a -> Bool) -> Proxy a -> Proxy a Source #
FilterableWithIndex i t => FilterableWithIndex i (Backwards t) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (i -> a -> Maybe b) -> Backwards t a -> Backwards t b Source # ifilter :: (i -> a -> Bool) -> Backwards t a -> Backwards t a Source #
FilterableWithIndex i t => FilterableWithIndex i (Reverse t) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (i -> a -> Maybe b) -> Reverse t a -> Reverse t b Source # ifilter :: (i -> a -> Bool) -> Reverse t a -> Reverse t a Source #
FilterableWithIndex i f => FilterableWithIndex i (IdentityT f) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (i -> a -> Maybe b) -> IdentityT f a -> IdentityT f b Source # ifilter :: (i -> a -> Bool) -> IdentityT f a -> IdentityT f a Source #
(FilterableWithIndex i f, FilterableWithIndex j g) => FilterableWithIndex (Either i j) (Sum f g) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (Either i j -> a -> Maybe b) -> Sum f g a -> Sum f g b Source # ifilter :: (Either i j -> a -> Bool) -> Sum f g a -> Sum f g a Source #
(FilterableWithIndex i f, FilterableWithIndex j g) => FilterableWithIndex (Either i j) (Product f g) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (Either i j -> a -> Maybe b) -> Product f g a -> Product f g b Source # ifilter :: (Either i j -> a -> Bool) -> Product f g a -> Product f g a Source #
(FunctorWithIndex i f, FilterableWithIndex j g) => FilterableWithIndex (i, j) (Compose f g) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: ((i, j) -> a -> Maybe b) -> Compose f g a -> Compose f g b Source # ifilter :: ((i, j) -> a -> Bool) -> Compose f g a -> Compose f g a Source #

class (TraversableWithIndex i t, Witherable t) => WitherableWithIndex i t | t -> i where Source #

Indexed variant of Witherable.

Minimal complete definition

Nothing

Methods

iwither :: Applicative f => (i -> a -> f (Maybe b)) -> t a -> f (t b) Source #

Effectful imapMaybe.

iwither ( i -> pure . f i) ≡ pure . imapMaybe f

iwitherM :: Monad m => (i -> a -> m (Maybe b)) -> t a -> m (t b) Source #

Monadic variant of wither. This may have more efficient implementation.

ifilterA :: Applicative f => (i -> a -> f Bool) -> t a -> f (t a) Source #

Instances

WitherableWithIndex Int [] Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (Int -> a -> f (Maybe b)) -> [a] -> f [b] Source # iwitherM :: Monad m => (Int -> a -> m (Maybe b)) -> [a] -> m [b] Source # ifilterA :: Applicative f => (Int -> a -> f Bool) -> [a] -> f [a] Source #
WitherableWithIndex Int ZipList Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (Int -> a -> f (Maybe b)) -> ZipList a -> f (ZipList b) Source # iwitherM :: Monad m => (Int -> a -> m (Maybe b)) -> ZipList a -> m (ZipList b) Source # ifilterA :: Applicative f => (Int -> a -> f Bool) -> ZipList a -> f (ZipList a) Source #
WitherableWithIndex Int IntMap Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (Int -> a -> f (Maybe b)) -> IntMap a -> f (IntMap b) Source # iwitherM :: Monad m => (Int -> a -> m (Maybe b)) -> IntMap a -> m (IntMap b) Source # ifilterA :: Applicative f => (Int -> a -> f Bool) -> IntMap a -> f (IntMap a) Source #
WitherableWithIndex Int Seq Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (Int -> a -> f (Maybe b)) -> Seq a -> f (Seq b) Source # iwitherM :: Monad m => (Int -> a -> m (Maybe b)) -> Seq a -> m (Seq b) Source # ifilterA :: Applicative f => (Int -> a -> f Bool) -> Seq a -> f (Seq a) Source #
WitherableWithIndex Int Vector Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (Int -> a -> f (Maybe b)) -> Vector a -> f (Vector b) Source # iwitherM :: Monad m => (Int -> a -> m (Maybe b)) -> Vector a -> m (Vector b) Source # ifilterA :: Applicative f => (Int -> a -> f Bool) -> Vector a -> f (Vector a) Source #
WitherableWithIndex () Maybe Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (() -> a -> f (Maybe b)) -> Maybe a -> f (Maybe b) Source # iwitherM :: Monad m => (() -> a -> m (Maybe b)) -> Maybe a -> m (Maybe b) Source # ifilterA :: Applicative f => (() -> a -> f Bool) -> Maybe a -> f (Maybe a) Source #
(Eq k, Hashable k) => WitherableWithIndex k (HashMap k) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (k -> a -> f (Maybe b)) -> HashMap k a -> f (HashMap k b) Source # iwitherM :: Monad m => (k -> a -> m (Maybe b)) -> HashMap k a -> m (HashMap k b) Source # ifilterA :: Applicative f => (k -> a -> f Bool) -> HashMap k a -> f (HashMap k a) Source #
WitherableWithIndex k (MonoidalMap k) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (k -> a -> f (Maybe b)) -> MonoidalMap k a -> f (MonoidalMap k b) Source # iwitherM :: Monad m => (k -> a -> m (Maybe b)) -> MonoidalMap k a -> m (MonoidalMap k b) Source # ifilterA :: Applicative f => (k -> a -> f Bool) -> MonoidalMap k a -> f (MonoidalMap k a) Source #
WitherableWithIndex k (Map k) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (k -> a -> f (Maybe b)) -> Map k a -> f (Map k b) Source # iwitherM :: Monad m => (k -> a -> m (Maybe b)) -> Map k a -> m (Map k b) Source # ifilterA :: Applicative f => (k -> a -> f Bool) -> Map k a -> f (Map k a) Source #
WitherableWithIndex Void (Proxy :: Type -> Type) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (Void -> a -> f (Maybe b)) -> Proxy a -> f (Proxy b) Source # iwitherM :: Monad m => (Void -> a -> m (Maybe b)) -> Proxy a -> m (Proxy b) Source # ifilterA :: Applicative f => (Void -> a -> f Bool) -> Proxy a -> f (Proxy a) Source #
WitherableWithIndex i t => WitherableWithIndex i (Backwards t) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (i -> a -> f (Maybe b)) -> Backwards t a -> f (Backwards t b) Source # iwitherM :: Monad m => (i -> a -> m (Maybe b)) -> Backwards t a -> m (Backwards t b) Source # ifilterA :: Applicative f => (i -> a -> f Bool) -> Backwards t a -> f (Backwards t a) Source #
WitherableWithIndex i t => WitherableWithIndex i (Reverse t) Source #	Wither from right to left.
Instance details Defined in Data.Witherable Methods iwither :: Applicative f => (i -> a -> f (Maybe b)) -> Reverse t a -> f (Reverse t b) Source # iwitherM :: Monad m => (i -> a -> m (Maybe b)) -> Reverse t a -> m (Reverse t b) Source # ifilterA :: Applicative f => (i -> a -> f Bool) -> Reverse t a -> f (Reverse t a) Source #
WitherableWithIndex i f => WitherableWithIndex i (IdentityT f) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f0 => (i -> a -> f0 (Maybe b)) -> IdentityT f a -> f0 (IdentityT f b) Source # iwitherM :: Monad m => (i -> a -> m (Maybe b)) -> IdentityT f a -> m (IdentityT f b) Source # ifilterA :: Applicative f0 => (i -> a -> f0 Bool) -> IdentityT f a -> f0 (IdentityT f a) Source #
(WitherableWithIndex i f, WitherableWithIndex j g) => WitherableWithIndex (Either i j) (Sum f g) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f0 => (Either i j -> a -> f0 (Maybe b)) -> Sum f g a -> f0 (Sum f g b) Source # iwitherM :: Monad m => (Either i j -> a -> m (Maybe b)) -> Sum f g a -> m (Sum f g b) Source # ifilterA :: Applicative f0 => (Either i j -> a -> f0 Bool) -> Sum f g a -> f0 (Sum f g a) Source #
(WitherableWithIndex i f, WitherableWithIndex j g) => WitherableWithIndex (Either i j) (Product f g) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f0 => (Either i j -> a -> f0 (Maybe b)) -> Product f g a -> f0 (Product f g b) Source # iwitherM :: Monad m => (Either i j -> a -> m (Maybe b)) -> Product f g a -> m (Product f g b) Source # ifilterA :: Applicative f0 => (Either i j -> a -> f0 Bool) -> Product f g a -> f0 (Product f g a) Source #
(TraversableWithIndex i f, WitherableWithIndex j g) => WitherableWithIndex (i, j) (Compose f g) Source #
Instance details Defined in Data.Witherable Methods iwither :: Applicative f0 => ((i, j) -> a -> f0 (Maybe b)) -> Compose f g a -> f0 (Compose f g b) Source # iwitherM :: Monad m => ((i, j) -> a -> m (Maybe b)) -> Compose f g a -> m (Compose f g b) Source # ifilterA :: Applicative f0 => ((i, j) -> a -> f0 Bool) -> Compose f g a -> f0 (Compose f g a) Source #

Generalization

type WitherLike f s t a b = (a -> f (Maybe b)) -> s -> f t Source #

This type allows combinators to take a Filter specializing the parameter f.

type Wither s t a b = forall f. Applicative f => WitherLike f s t a b Source #

A Wither is like a Traversal, but you can also remove targets.

type WitherLike' f s a = WitherLike f s s a a Source #

A simple WitherLike.

type Wither' s a = forall f. Applicative f => WitherLike' f s a Source #

A simple Wither.

type FilterLike f s t a b = WitherLike f s t a b Source #

Deprecated: Use WitherLike instead

type Filter s t a b = Wither s t a b Source #

Deprecated: Use Wither instead

type FilterLike' f s a = WitherLike' f s a Source #

Deprecated: Use WitherLike' instead

type Filter' s a = Wither' s a Source #

Deprecated: Use Filter' instead

witherOf :: FilterLike f s t a b -> (a -> f (Maybe b)) -> s -> f t Source #

witherOf is actually id, but left for consistency.

forMaybeOf :: FilterLike f s t a b -> s -> (a -> f (Maybe b)) -> f t Source #

forMaybeOf ≡ flip

mapMaybeOf :: FilterLike Identity s t a b -> (a -> Maybe b) -> s -> t Source #

mapMaybe through a filter.

catMaybesOf :: FilterLike Identity s t (Maybe a) a -> s -> t Source #

catMaybes through a filter.

filterAOf :: Functor f => FilterLike' f s a -> (a -> f Bool) -> s -> f s Source #

filterA through a filter.

filterOf :: FilterLike' Identity s a -> (a -> Bool) -> s -> s Source #

Filter each element of a structure targeted by a Filter.

ordNubOf :: Ord a => FilterLike' (State (Set a)) s a -> s -> s Source #

Remove the duplicate elements through a filter.

hashNubOf :: (Eq a, Hashable a) => FilterLike' (State (HashSet a)) s a -> s -> s Source #

Remove the duplicate elements through a filter. It is often faster than ordNubOf, especially when the comparison is expensive.

Cloning

cloneFilter :: FilterLike (Peat a b) s t a b -> Filter s t a b Source #

Reconstitute a Filter from its monomorphic form.

newtype Peat a b t Source #

This is used to characterize and clone a Filter. Since FilterLike (Peat a b) s t a b is monomorphic, it can be used to store a filter in a container.

Constructors

Peat
Fields runPeat :: forall f. Applicative f => (a -> f (Maybe b)) -> f t

Instances

Functor (Peat a b) Source #
Instance details Defined in Data.Witherable Methods fmap :: (a0 -> b0) -> Peat a b a0 -> Peat a b b0 # (<$) :: a0 -> Peat a b b0 -> Peat a b a0 #
Applicative (Peat a b) Source #
Instance details Defined in Data.Witherable Methods pure :: a0 -> Peat a b a0 # (<>) :: Peat a b (a0 -> b0) -> Peat a b a0 -> Peat a b b0 # liftA2 :: (a0 -> b0 -> c) -> Peat a b a0 -> Peat a b b0 -> Peat a b c # (>) :: Peat a b a0 -> Peat a b b0 -> Peat a b b0 # (<*) :: Peat a b a0 -> Peat a b b0 -> Peat a b a0 #

Wrapper

newtype WrappedFoldable f a Source #

Constructors

WrapFilterable
Fields unwrapFoldable :: f a

Instances

FunctorWithIndex i f => FunctorWithIndex i (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods imap :: (i -> a -> b) -> WrappedFoldable f a -> WrappedFoldable f b # imapped :: IndexedSetter i (WrappedFoldable f a) (WrappedFoldable f b) a b #
FoldableWithIndex i f => FoldableWithIndex i (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods ifoldMap :: Monoid m => (i -> a -> m) -> WrappedFoldable f a -> m # ifolded :: IndexedFold i (WrappedFoldable f a) a # ifoldr :: (i -> a -> b -> b) -> b -> WrappedFoldable f a -> b # ifoldl :: (i -> b -> a -> b) -> b -> WrappedFoldable f a -> b # ifoldr' :: (i -> a -> b -> b) -> b -> WrappedFoldable f a -> b # ifoldl' :: (i -> b -> a -> b) -> b -> WrappedFoldable f a -> b #
TraversableWithIndex i f => TraversableWithIndex i (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods itraverse :: Applicative f0 => (i -> a -> f0 b) -> WrappedFoldable f a -> f0 (WrappedFoldable f b) # itraversed :: IndexedTraversal i (WrappedFoldable f a) (WrappedFoldable f b) a b #
(FunctorWithIndex i f, FoldableWithIndex i f, Alternative f) => FilterableWithIndex i (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods imapMaybe :: (i -> a -> Maybe b) -> WrappedFoldable f a -> WrappedFoldable f b Source # ifilter :: (i -> a -> Bool) -> WrappedFoldable f a -> WrappedFoldable f a Source #
Functor f => Functor (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods fmap :: (a -> b) -> WrappedFoldable f a -> WrappedFoldable f b # (<$) :: a -> WrappedFoldable f b -> WrappedFoldable f a #
Applicative f => Applicative (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods pure :: a -> WrappedFoldable f a # (<>) :: WrappedFoldable f (a -> b) -> WrappedFoldable f a -> WrappedFoldable f b # liftA2 :: (a -> b -> c) -> WrappedFoldable f a -> WrappedFoldable f b -> WrappedFoldable f c # (>) :: WrappedFoldable f a -> WrappedFoldable f b -> WrappedFoldable f b # (<*) :: WrappedFoldable f a -> WrappedFoldable f b -> WrappedFoldable f a #
Foldable f => Foldable (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods fold :: Monoid m => WrappedFoldable f m -> m # foldMap :: Monoid m => (a -> m) -> WrappedFoldable f a -> m # foldr :: (a -> b -> b) -> b -> WrappedFoldable f a -> b # foldr' :: (a -> b -> b) -> b -> WrappedFoldable f a -> b # foldl :: (b -> a -> b) -> b -> WrappedFoldable f a -> b # foldl' :: (b -> a -> b) -> b -> WrappedFoldable f a -> b # foldr1 :: (a -> a -> a) -> WrappedFoldable f a -> a # foldl1 :: (a -> a -> a) -> WrappedFoldable f a -> a # toList :: WrappedFoldable f a -> [a] # null :: WrappedFoldable f a -> Bool # length :: WrappedFoldable f a -> Int # elem :: Eq a => a -> WrappedFoldable f a -> Bool # maximum :: Ord a => WrappedFoldable f a -> a # minimum :: Ord a => WrappedFoldable f a -> a # sum :: Num a => WrappedFoldable f a -> a # product :: Num a => WrappedFoldable f a -> a #
Traversable f => Traversable (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods traverse :: Applicative f0 => (a -> f0 b) -> WrappedFoldable f a -> f0 (WrappedFoldable f b) # sequenceA :: Applicative f0 => WrappedFoldable f (f0 a) -> f0 (WrappedFoldable f a) # mapM :: Monad m => (a -> m b) -> WrappedFoldable f a -> m (WrappedFoldable f b) # sequence :: Monad m => WrappedFoldable f (m a) -> m (WrappedFoldable f a) #
Alternative f => Alternative (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods empty :: WrappedFoldable f a # (<\|>) :: WrappedFoldable f a -> WrappedFoldable f a -> WrappedFoldable f a # some :: WrappedFoldable f a -> WrappedFoldable f [a] # many :: WrappedFoldable f a -> WrappedFoldable f [a] #
(Foldable f, Alternative f) => Filterable (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods mapMaybe :: (a -> Maybe b) -> WrappedFoldable f a -> WrappedFoldable f b # catMaybes :: WrappedFoldable f (Maybe a) -> WrappedFoldable f a # filter :: (a -> Bool) -> WrappedFoldable f a -> WrappedFoldable f a #
(Alternative f, Traversable f) => Witherable (WrappedFoldable f) Source #
Instance details Defined in Data.Witherable Methods wither :: Applicative f0 => (a -> f0 (Maybe b)) -> WrappedFoldable f a -> f0 (WrappedFoldable f b) # witherM :: Monad m => (a -> m (Maybe b)) -> WrappedFoldable f a -> m (WrappedFoldable f b) # filterA :: Applicative f0 => (a -> f0 Bool) -> WrappedFoldable f a -> f0 (WrappedFoldable f a) #

Orphan instances

Filterable (MonoidalMap k) Source #
Instance details Methods mapMaybe :: (a -> Maybe b) -> MonoidalMap k a -> MonoidalMap k b # catMaybes :: MonoidalMap k (Maybe a) -> MonoidalMap k a # filter :: (a -> Bool) -> MonoidalMap k a -> MonoidalMap k a #
Witherable (MonoidalMap k) Source #
Instance details Methods wither :: Applicative f => (a -> f (Maybe b)) -> MonoidalMap k a -> f (MonoidalMap k b) # witherM :: Monad m => (a -> m (Maybe b)) -> MonoidalMap k a -> m (MonoidalMap k b) # filterA :: Applicative f => (a -> f Bool) -> MonoidalMap k a -> f (MonoidalMap k a) #