Data.Filtrable

Documentation

class Functor f => Filtrable f where

Laws:

• mapMaybe Just = id

• mapMaybe f = catMaybes ∘ fmap f

• catMaybes = mapMaybe id

• filter f = mapMaybe (\ x -> bool Nothing (Just x) (f x))

• mapMaybe g . mapMaybe f = mapMaybe (g <=< f)

Laws if Foldable f:

• foldMap g . filter f = foldMap (\ x -> bool mempty (g x) (f x))

Minimal complete definition

mapMaybe | catMaybes

Methods

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

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

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

mapMaybeA :: (Traversable f, Applicative p) => (a -> p (Maybe b)) -> f a -> p (f b)

filterA :: (Traversable f, Applicative p) => (a -> p Bool) -> f a -> p (f a)

mapEither :: (a -> Either b c) -> f a -> (f b, f c)

mapEitherA :: (Traversable f, Applicative p) => (a -> p (Either b c)) -> f a -> p (f b, f c)

partitionEithers :: f (Either a b) -> (f a, f b)

Instances

Filtrable []

Methods

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

catMaybes :: [Maybe a] -> [a]

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

mapMaybeA :: (Traversable [], Applicative p) => (a -> p (Maybe b)) -> [a] -> p [b]

filterA :: (Traversable [], Applicative p) => (a -> p Bool) -> [a] -> p [a]

mapEither :: (a -> Either b c) -> [a] -> ([b], [c])

mapEitherA :: (Traversable [], Applicative p) => (a -> p (Either b c)) -> [a] -> p ([b], [c])

partitionEithers :: [Either a b] -> ([a], [b])

Filtrable Maybe

Methods

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

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

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

mapMaybeA :: (Traversable Maybe, Applicative p) => (a -> p (Maybe b)) -> Maybe a -> p (Maybe b)

filterA :: (Traversable Maybe, Applicative p) => (a -> p Bool) -> Maybe a -> p (Maybe a)

mapEither :: (a -> Either b c) -> Maybe a -> (Maybe b, Maybe c)

mapEitherA :: (Traversable Maybe, Applicative p) => (a -> p (Either b c)) -> Maybe a -> p (Maybe b, Maybe c)

partitionEithers :: Maybe (Either a b) -> (Maybe a, Maybe b)

Filtrable (Proxy *)

Methods

mapMaybe :: (a -> Maybe b) -> Proxy * a -> Proxy * b

catMaybes :: Proxy * (Maybe a) -> Proxy * a

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

mapMaybeA :: (Traversable (Proxy *), Applicative p) => (a -> p (Maybe b)) -> Proxy * a -> p (Proxy * b)

filterA :: (Traversable (Proxy *), Applicative p) => (a -> p Bool) -> Proxy * a -> p (Proxy * a)

mapEither :: (a -> Either b c) -> Proxy * a -> (Proxy * b, Proxy * c)

mapEitherA :: (Traversable (Proxy *), Applicative p) => (a -> p (Either b c)) -> Proxy * a -> p (Proxy * b, Proxy * c)

partitionEithers :: Proxy * (Either a b) -> (Proxy * a, Proxy * b)

Filtrable (Const * a)

Methods

mapMaybe :: (a -> Maybe b) -> Const * a a -> Const * a b

catMaybes :: Const * a (Maybe a) -> Const * a a

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

mapMaybeA :: (Traversable (Const * a), Applicative p) => (a -> p (Maybe b)) -> Const * a a -> p (Const * a b)

filterA :: (Traversable (Const * a), Applicative p) => (a -> p Bool) -> Const * a a -> p (Const * a a)

mapEither :: (a -> Either b c) -> Const * a a -> (Const * a b, Const * a c)

mapEitherA :: (Traversable (Const * a), Applicative p) => (a -> p (Either b c)) -> Const * a a -> p (Const * a b, Const * a c)

partitionEithers :: Const * a (Either a b) -> (Const * a a, Const * a b)