Copyright  (c) Fumiaki Kinoshita 2015 

License  BSD3 
Maintainer  Fumiaki Kinoshita <fumiexcel@gmail.com> 
Stability  provisional 
Portability  nonportable 
Safe Haskell  Trustworthy 
Language  Haskell2010 
 class Functor f => Filterable f where
 class (Traversable t, Filterable t) => Witherable t where
 witherM :: (Witherable t, Monad m) => (a > MaybeT m b) > t a > m (t b)
 blightM :: (Monad m, Witherable t) => t a > (a > MaybeT m b) > m (t b)
 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)
 type FilterLike f s t a b = (a > f (Maybe b)) > s > f t
 type Filter s t a b = forall f. Applicative f => FilterLike f s t a b
 type FilterLike' f s a = FilterLike f s s a a
 type Filter' s a = forall f. Applicative f => FilterLike' f 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
Documentation
class Functor f => Filterable f where Source #
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:
mapMaybe :: (a > Maybe b) > f a > f b Source #
Like mapMaybe
.
Filterable [] Source #  
Filterable Maybe Source #  
Filterable IntMap Source #  
Filterable Seq Source #  
Filterable Vector Source #  
Monoid e => Filterable (Either e) Source #  
Filterable (Proxy *) Source #  
Filterable (Map k) Source #  
Functor f => Filterable (MaybeT f) Source #  
(Eq k, Hashable k) => Filterable (HashMap k) Source #  
Filterable (Const * r) Source #  
(Functor f, Filterable g) => Filterable (Compose * * f g) Source #  
class (Traversable t, Filterable t) => Witherable t where Source #
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)
wither :: Applicative f => (a > f (Maybe b)) > t a > f (t b) Source #
filterA :: Applicative f => (a > f Bool) > t a > f (t a) Source #
Witherable [] Source #  
Witherable Maybe Source #  
Witherable IntMap Source #  
Witherable Seq Source #  
Witherable Vector Source #  
Monoid e => Witherable (Either e) Source #  
Witherable (Proxy *) Source #  
Witherable (Map k) Source #  
Traversable t => Witherable (MaybeT t) Source #  
(Eq k, Hashable k) => Witherable (HashMap k) Source #  
Witherable (Const * r) Source #  
(Traversable f, Witherable g) => Witherable (Compose * * f g) Source #  
ordNub :: (Witherable t, Ord a) => t a > t a Source #
forMaybe :: (Witherable t, Applicative f) => t a > (a > f (Maybe b)) > f (t b) Source #
Generalization
type FilterLike 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 Filter s t a b = forall f. Applicative f => FilterLike f s t a b Source #
type FilterLike' f s a = FilterLike f s s a a Source #
A simple FilterLike
.
type Filter' s a = forall f. Applicative f => FilterLike' f s a Source #
A simple Filter
.
witherOf :: FilterLike f s t a b > (a > f (Maybe b)) > s > f t Source #
forMaybeOf :: FilterLike f s t a b > s > (a > f (Maybe b)) > f t Source #
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.
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.
Peat  
