witherable-0.2: filterable traversable

Copyright (c) Fumiaki Kinoshita 2015 BSD3 Fumiaki Kinoshita provisional non-portable Trustworthy Haskell2010

Data.Witherable

Contents

Description

Synopsis

# 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:

identity
mapMaybe Just ≡ id
composition
mapMaybe f . mapMaybe g ≡ mapMaybe (f <=< g)

Minimal complete definition

Methods

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

Like mapMaybe.

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

catMaybes ≡ mapMaybe id

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

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

Instances

 Source # MethodsmapMaybe :: (a -> Maybe b) -> [a] -> [b] Source #catMaybes :: [Maybe a] -> [a] Source #filter :: (a -> Bool) -> [a] -> [a] Source # Source # MethodsmapMaybe :: (a -> Maybe b) -> Maybe a -> Maybe b Source #catMaybes :: Maybe (Maybe a) -> Maybe a Source #filter :: (a -> Bool) -> Maybe a -> Maybe a Source # Source # MethodsmapMaybe :: (a -> Maybe b) -> IntMap a -> IntMap b Source #catMaybes :: IntMap (Maybe a) -> IntMap a Source #filter :: (a -> Bool) -> IntMap a -> IntMap a Source # Source # MethodsmapMaybe :: (a -> Maybe b) -> Seq a -> Seq b Source #catMaybes :: Seq (Maybe a) -> Seq a Source #filter :: (a -> Bool) -> Seq a -> Seq a Source # Source # MethodsmapMaybe :: (a -> Maybe b) -> Vector a -> Vector b Source #catMaybes :: Vector (Maybe a) -> Vector a Source #filter :: (a -> Bool) -> Vector a -> Vector a Source # Monoid e => Filterable (Either e) Source # MethodsmapMaybe :: (a -> Maybe b) -> Either e a -> Either e b Source #catMaybes :: Either e (Maybe a) -> Either e a Source #filter :: (a -> Bool) -> Either e a -> Either e a Source # Source # MethodsmapMaybe :: (a -> Maybe b) -> Proxy * a -> Proxy * b Source #catMaybes :: Proxy * (Maybe a) -> Proxy * a Source #filter :: (a -> Bool) -> Proxy * a -> Proxy * a Source # Source # MethodsmapMaybe :: (a -> Maybe b) -> Map k a -> Map k b Source #catMaybes :: Map k (Maybe a) -> Map k a Source #filter :: (a -> Bool) -> Map k a -> Map k a Source # Functor f => Filterable (MaybeT f) Source # MethodsmapMaybe :: (a -> Maybe b) -> MaybeT f a -> MaybeT f b Source #catMaybes :: MaybeT f (Maybe a) -> MaybeT f a Source #filter :: (a -> Bool) -> MaybeT f a -> MaybeT f a Source # (Eq k, Hashable k) => Filterable (HashMap k) Source # MethodsmapMaybe :: (a -> Maybe b) -> HashMap k a -> HashMap k b Source #catMaybes :: HashMap k (Maybe a) -> HashMap k a Source #filter :: (a -> Bool) -> HashMap k a -> HashMap k a Source # Source # MethodsmapMaybe :: (a -> Maybe b) -> Const * r a -> Const * r b Source #catMaybes :: Const * r (Maybe a) -> Const * r a Source #filter :: (a -> Bool) -> Const * r a -> Const * r a Source # (Functor f, Filterable g) => Filterable (Compose * * f g) Source # MethodsmapMaybe :: (a -> Maybe b) -> Compose * * f g a -> Compose * * f g b Source #catMaybes :: Compose * * f g (Maybe a) -> Compose * * f g a Source #filter :: (a -> Bool) -> Compose * * f g a -> Compose * * f g a 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)

Methods

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

traverse f ≡ wither (fmap Just . f)

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

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

Instances

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

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

A variant of wither that works on MaybeT.

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

blightM is witherM with its arguments flipped.

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 comparion (like String).

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

forMaybe = flip wither

# 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 #

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

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 #

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 FieldsrunPeat :: forall f. Applicative f => (a -> f (Maybe b)) -> f t

Instances

 Functor (Peat a b) Source # Methodsfmap :: (a -> b) -> Peat a b a -> Peat a b b #(<\$) :: a -> Peat a b b -> Peat a b a # Applicative (Peat a b) Source # Methodspure :: 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 #