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

Data.Witherable

Contents

Generalization
Cloning
Witherable from Traversable

Description

Synopsis

Documentation

class Traversable 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
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

wither | mapMaybe | catMaybes

Methods

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

traverse f ≡ wither (fmap Just . f)

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

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

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

catMaybes ≡ mapMaybe id

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)

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

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

Instances

Witherable [] #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> [a] -> f [b] # mapMaybe :: (a -> Maybe b) -> [a] -> [b] # catMaybes :: [Maybe a] -> [a] # filterA :: Applicative f => (a -> f Bool) -> [a] -> f [a] # filter :: (a -> Bool) -> [a] -> [a] #
Witherable Maybe #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Maybe a -> f (Maybe b) # mapMaybe :: (a -> Maybe b) -> Maybe a -> Maybe b # catMaybes :: Maybe (Maybe a) -> Maybe a # filterA :: Applicative f => (a -> f Bool) -> Maybe a -> f (Maybe a) # filter :: (a -> Bool) -> Maybe a -> Maybe a #
Witherable IntMap #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> IntMap a -> f (IntMap b) # mapMaybe :: (a -> Maybe b) -> IntMap a -> IntMap b # catMaybes :: IntMap (Maybe a) -> IntMap a # filterA :: Applicative f => (a -> f Bool) -> IntMap a -> f (IntMap a) # filter :: (a -> Bool) -> IntMap a -> IntMap a #
Witherable Seq #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Seq a -> f (Seq b) # mapMaybe :: (a -> Maybe b) -> Seq a -> Seq b # catMaybes :: Seq (Maybe a) -> Seq a # filterA :: Applicative f => (a -> f Bool) -> Seq a -> f (Seq a) # filter :: (a -> Bool) -> Seq a -> Seq a #
Witherable Vector #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Vector a -> f (Vector b) # mapMaybe :: (a -> Maybe b) -> Vector a -> Vector b # catMaybes :: Vector (Maybe a) -> Vector a # filterA :: Applicative f => (a -> f Bool) -> Vector a -> f (Vector a) # filter :: (a -> Bool) -> Vector a -> Vector a #
Monoid e => Witherable (Either e) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Either e a -> f (Either e b) # mapMaybe :: (a -> Maybe b) -> Either e a -> Either e b # catMaybes :: Either e (Maybe a) -> Either e a # filterA :: Applicative f => (a -> f Bool) -> Either e a -> f (Either e a) # filter :: (a -> Bool) -> Either e a -> Either e a #
Witherable (Proxy *) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Proxy * a -> f (Proxy * b) # mapMaybe :: (a -> Maybe b) -> Proxy * a -> Proxy * b # catMaybes :: Proxy * (Maybe a) -> Proxy * a # filterA :: Applicative f => (a -> f Bool) -> Proxy * a -> f (Proxy * a) # filter :: (a -> Bool) -> Proxy * a -> Proxy * a #
Witherable (Map k) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Map k a -> f (Map k b) # mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b # catMaybes :: Map k (Maybe a) -> Map k a # filterA :: Applicative f => (a -> f Bool) -> Map k a -> f (Map k a) # filter :: (a -> Bool) -> Map k a -> Map k a #
Traversable t => Witherable (MaybeT t) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> MaybeT t a -> f (MaybeT t b) # mapMaybe :: (a -> Maybe b) -> MaybeT t a -> MaybeT t b # catMaybes :: MaybeT t (Maybe a) -> MaybeT t a # filterA :: Applicative f => (a -> f Bool) -> MaybeT t a -> f (MaybeT t a) # filter :: (a -> Bool) -> MaybeT t a -> MaybeT t a #
(Eq k, Hashable k) => Witherable (HashMap k) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> HashMap k a -> f (HashMap k b) # mapMaybe :: (a -> Maybe b) -> HashMap k a -> HashMap k b # catMaybes :: HashMap k (Maybe a) -> HashMap k a # filterA :: Applicative f => (a -> f Bool) -> HashMap k a -> f (HashMap k a) # filter :: (a -> Bool) -> HashMap k a -> HashMap k a #
Traversable t => Witherable (Chipped t) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Chipped t a -> f (Chipped t b) # mapMaybe :: (a -> Maybe b) -> Chipped t a -> Chipped t b # catMaybes :: Chipped t (Maybe a) -> Chipped t a # filterA :: Applicative f => (a -> f Bool) -> Chipped t a -> f (Chipped t a) # filter :: (a -> Bool) -> Chipped t a -> Chipped t a #
Witherable (Const * r) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Const * r a -> f (Const * r b) # mapMaybe :: (a -> Maybe b) -> Const * r a -> Const * r b # catMaybes :: Const * r (Maybe a) -> Const * r a # filterA :: Applicative f => (a -> f Bool) -> Const * r a -> f (Const * r a) # filter :: (a -> Bool) -> Const * r a -> Const * r a #
(Traversable f, Witherable g) => Witherable (Compose * * f g) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Compose * * f g a -> f (Compose * * f g b) # mapMaybe :: (a -> Maybe b) -> Compose * * f g a -> Compose * * f g b # catMaybes :: Compose * * f g (Maybe a) -> Compose * * f g a # filterA :: Applicative f => (a -> f Bool) -> Compose * * f g a -> f (Compose * * f g a) # filter :: (a -> Bool) -> Compose * * f g a -> Compose * * f g a #

witherM :: (Witherable t, Monad m) => (a -> MaybeT m b) -> t a -> m (t b) #

A variant of wither that works on MaybeT.

blightM :: (Monad m, Witherable t) => t a -> (a -> MaybeT m b) -> m (t b) #

blightM is witherM with its arguments flipped.

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 comparion (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) #
Methods fmap :: (a -> b) -> Peat a b a -> Peat a b b # (<$) :: a -> Peat a b b -> Peat a b a #
Applicative (Peat a b) #
Methods pure :: a -> Peat a b a # (<>) :: Peat a b (a -> b) -> Peat a b a -> Peat a b b # (>) :: Peat a b a -> Peat a b b -> Peat a b b # (<*) :: Peat a b a -> Peat a b b -> Peat a b a #

Witherable from Traversable

newtype Chipped t a #

Deprecated: Use 'Compose t Maybe' instead

Traversable containers which hold Maybe are witherable.

Constructors

Chipped	Deprecated: Use 'Compose t Maybe' instead
Fields getChipped :: t (Maybe a)

Instances

Functor t => Functor (Chipped t) #
Methods fmap :: (a -> b) -> Chipped t a -> Chipped t b # (<$) :: a -> Chipped t b -> Chipped t a #
Applicative t => Applicative (Chipped t) #
Methods pure :: a -> Chipped t a # (<>) :: Chipped t (a -> b) -> Chipped t a -> Chipped t b # (>) :: Chipped t a -> Chipped t b -> Chipped t b # (<*) :: Chipped t a -> Chipped t b -> Chipped t a #
Foldable t => Foldable (Chipped t) #
Methods fold :: Monoid m => Chipped t m -> m # foldMap :: Monoid m => (a -> m) -> Chipped t a -> m # foldr :: (a -> b -> b) -> b -> Chipped t a -> b # foldr' :: (a -> b -> b) -> b -> Chipped t a -> b # foldl :: (b -> a -> b) -> b -> Chipped t a -> b # foldl' :: (b -> a -> b) -> b -> Chipped t a -> b # foldr1 :: (a -> a -> a) -> Chipped t a -> a # foldl1 :: (a -> a -> a) -> Chipped t a -> a # toList :: Chipped t a -> [a] # null :: Chipped t a -> Bool # length :: Chipped t a -> Int # elem :: Eq a => a -> Chipped t a -> Bool # maximum :: Ord a => Chipped t a -> a # minimum :: Ord a => Chipped t a -> a # sum :: Num a => Chipped t a -> a # product :: Num a => Chipped t a -> a #
Traversable t => Traversable (Chipped t) #
Methods traverse :: Applicative f => (a -> f b) -> Chipped t a -> f (Chipped t b) # sequenceA :: Applicative f => Chipped t (f a) -> f (Chipped t a) # mapM :: Monad m => (a -> m b) -> Chipped t a -> m (Chipped t b) # sequence :: Monad m => Chipped t (m a) -> m (Chipped t a) #
Traversable t => Witherable (Chipped t) #
Methods wither :: Applicative f => (a -> f (Maybe b)) -> Chipped t a -> f (Chipped t b) # mapMaybe :: (a -> Maybe b) -> Chipped t a -> Chipped t b # catMaybes :: Chipped t (Maybe a) -> Chipped t a # filterA :: Applicative f => (a -> f Bool) -> Chipped t a -> f (Chipped t a) # filter :: (a -> Bool) -> Chipped t a -> Chipped t a #
Eq (t (Maybe a)) => Eq (Chipped t a) #
Methods (==) :: Chipped t a -> Chipped t a -> Bool # (/=) :: Chipped t a -> Chipped t a -> Bool #
Ord (t (Maybe a)) => Ord (Chipped t a) #
Methods compare :: Chipped t a -> Chipped t a -> Ordering # (<) :: Chipped t a -> Chipped t a -> Bool # (<=) :: Chipped t a -> Chipped t a -> Bool # (>) :: Chipped t a -> Chipped t a -> Bool # (>=) :: Chipped t a -> Chipped t a -> Bool # max :: Chipped t a -> Chipped t a -> Chipped t a # min :: Chipped t a -> Chipped t a -> Chipped t a #
Read (t (Maybe a)) => Read (Chipped t a) #
Methods readsPrec :: Int -> ReadS (Chipped t a) # readList :: ReadS [Chipped t a] # readPrec :: ReadPrec (Chipped t a) # readListPrec :: ReadPrec [Chipped t a] #
Show (t (Maybe a)) => Show (Chipped t a) #
Methods showsPrec :: Int -> Chipped t a -> ShowS # show :: Chipped t a -> String # showList :: [Chipped t a] -> ShowS #