Data.Witherable

Documentation

class Functor f => Filterable f where

Like Functor, but it include Maybe effects.

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

A definition of mapMaybe must satisfy the following laws:

identity

mapMaybe Just ≡ id

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

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

Instances

Filterable []

Defined in Data.Witherable

Methods

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

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

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

Filterable Maybe

Defined in Data.Witherable

Methods

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

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

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

Filterable IntMap

Defined in Data.Witherable

Methods

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

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

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

Filterable Seq

Defined in Data.Witherable

Methods

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

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

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

Filterable Vector

Defined in Data.Witherable

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)

Defined in Data.Witherable

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 (Proxy :: Type -> Type)

Defined in Data.Witherable

Methods

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

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

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

Filterable (Map k)

Defined in Data.Witherable

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

Functor f => Filterable (MaybeT f)

Defined in Data.Witherable

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

(Eq k, Hashable k) => Filterable (HashMap k)

Defined in Data.Witherable

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 (Const r :: Type -> Type)

Defined in Data.Witherable

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)

Defined in Data.Witherable

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 f, Filterable g) => Filterable (Product f g)

Defined in Data.Witherable

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)

Defined in Data.Witherable

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

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

Defined in Data.Witherable

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

class (Traversable t, Filterable t) => Witherable t where

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

A definition of wither must satisfy the following laws:

identity

wither (pure . Just) ≡ pure

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)

traverse f ≡ wither (fmap Just . 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)

Compose . fmap (filterA f) . filterA g ≡ filterA (x -> Compose $ fmap (b -> (b&&) $ f x) (g x)

Instances

Witherable []

Defined in Data.Witherable

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

Defined in Data.Witherable

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 IntMap

Defined in Data.Witherable

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

Defined in Data.Witherable

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

Defined in Data.Witherable

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)

Defined in Data.Witherable

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 (Proxy :: Type -> Type)

Defined in Data.Witherable

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)

Witherable (Map k)

Defined in Data.Witherable

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)

Traversable t => Witherable (MaybeT t)

Defined in Data.Witherable

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)

(Eq k, Hashable k) => Witherable (HashMap k)

Defined in Data.Witherable

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 (Const r :: Type -> Type)

Defined in Data.Witherable

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)

Defined in Data.Witherable

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 f, Witherable g) => Witherable (Product f g)

Defined in Data.Witherable

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)

Defined in Data.Witherable

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)

(Traversable f, Witherable g) => Witherable (Compose f g)

Defined in Data.Witherable

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

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

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)

forMaybe = flip wither

Generalization

type FilterLike f s t a b = (a -> f (Maybe b)) -> s -> f t

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

type Filter s t a b = forall f. Applicative f => FilterLike f s t a b

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

type FilterLike' f s a = FilterLike f s s a a

A simple FilterLike.

type Filter' s a = forall f. Applicative f => FilterLike' f s a

A simple Filter.

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

witherOf is actually id, but left for consistency.

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

forMaybeOf ≡ flip

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

mapMaybe through a filter.

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

catMaybes through a filter.

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

filterA through a filter.

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

Filter each element of a structure targeted by a Filter.

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

Remove the duplicate elements through a filter.

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

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

Reconstitute a Filter from its monomorphic form.

newtype Peat a b t

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)

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)

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