-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | filterable traversable
--   
--   A stronger variant of <a>traverse</a> which can remove elements and
--   generalised mapMaybe, catMaybes, filter
@package witherable
@version 0.3.3


module Data.Witherable

-- | Like <a>Functor</a>, but you can remove elements instead of updating
--   them.
--   
--   Formally, the class <a>Filterable</a> represents a functor from
--   <tt>Kleisli Maybe</tt> to <tt>Hask</tt>.
--   
--   A definition of <a>mapMaybe</a> must satisfy the following laws:
--   
--   <ul>
--   <li><i><i>conservation</i></i> <tt><a>mapMaybe</a> (Just . f) ≡
--   <a>fmap</a> f</tt></li>
--   <li><i><i>composition</i></i> <tt><a>mapMaybe</a> f . <a>mapMaybe</a>
--   g ≡ <a>mapMaybe</a> (f &lt;=&lt; g)</tt></li>
--   </ul>
class Functor f => Filterable f

-- | Like <a>mapMaybe</a>.
mapMaybe :: Filterable f => (a -> Maybe b) -> f a -> f b

-- | <pre>
--   <a>catMaybes</a> ≡ <a>mapMaybe</a> <a>id</a>
--   </pre>
catMaybes :: Filterable f => f (Maybe a) -> f a

-- | <pre>
--   <a>Filterable</a> f . <a>Filterable</a> g ≡ filter (<a>liftA2</a> (<a>&amp;&amp;</a>) f g)
--   </pre>
filter :: Filterable f => (a -> Bool) -> f a -> f a

-- | An infix alias for <a>mapMaybe</a>. The name of the operator alludes
--   to <a>&lt;$&gt;</a>, and has the same fixity.
(<$?>) :: Filterable f => (a -> Maybe b) -> f a -> f b
infixl 4 <$?>

-- | Flipped version of <a>&lt;$?&gt;</a>, the <a>Filterable</a> version of
--   <a>&lt;&amp;&gt;</a>. It has the same fixity as <a>&lt;&amp;&gt;</a>.
--   
--   <pre>
--   (<a>&lt;&amp;?&gt;</a>) = <a>flip</a> <a>mapMaybe</a>
--   </pre>
(<&?>) :: Filterable f => f a -> (a -> Maybe b) -> f b
infixl 1 <&?>

-- | An enhancement of <a>Traversable</a> with <a>Filterable</a>
--   
--   A definition of <a>wither</a> must satisfy the following laws:
--   
--   <ul>
--   <li><i><i>conservation</i></i> <tt><a>wither</a> (<a>fmap</a>
--   <a>Just</a> . f) ≡ <a>traverse</a> f</tt></li>
--   <li><i><i>composition</i></i> <tt><a>Compose</a> . <a>fmap</a>
--   (<a>wither</a> f) . <a>wither</a> g ≡ <a>wither</a> (<a>Compose</a> .
--   <a>fmap</a> (<a>wither</a> f) . g)</tt></li>
--   </ul>
--   
--   Parametricity implies the naturality law:
--   
--   <pre>
--   t . <a>wither</a> f ≡ <a>wither</a> (t . f)
--   </pre>
class (Traversable t, Filterable t) => Witherable t

-- | Effectful <a>mapMaybe</a>.
--   
--   <pre>
--   <a>wither</a> (<a>pure</a> . f) ≡ <a>pure</a> . <a>mapMaybe</a> f
--   </pre>
wither :: (Witherable t, Applicative f) => (a -> f (Maybe b)) -> t a -> f (t b)

-- | <pre>
--   Monadic variant of <a>wither</a>. This may have more efficient implementation.
--   </pre>
witherM :: (Witherable t, Monad m) => (a -> m (Maybe b)) -> t a -> m (t b)
filterA :: (Witherable t, Applicative f) => (a -> f Bool) -> t a -> f (t a)

-- | Removes duplicate elements from a list, keeping only the first
--   occurrence. This is asymptotically faster than using <a>nub</a> from
--   <a>Data.List</a>.
ordNub :: (Witherable t, Ord a) => t a -> t a

-- | Removes duplicate elements from a list, keeping only the first
--   occurrence. This is usually faster than <a>ordNub</a>, especially for
--   things that have a slow comparison (like <a>String</a>).
hashNub :: (Witherable t, Eq a, Hashable a) => t a -> t a

-- | <pre>
--   <a>forMaybe</a> = <a>flip</a> <a>wither</a>
--   </pre>
forMaybe :: (Witherable t, Applicative f) => t a -> (a -> f (Maybe b)) -> f (t b)

-- | Indexed variant of <a>Filterable</a>.
class (FunctorWithIndex i t, Filterable t) => FilterableWithIndex i t | t -> i
imapMaybe :: FilterableWithIndex i t => (i -> a -> Maybe b) -> t a -> t b

-- | <pre>
--   <a>ifilter</a> f . <a>ifilter</a> g ≡ ifilter (i -&gt; <a>liftA2</a> (<a>&amp;&amp;</a>) (f i) (g i))
--   </pre>
ifilter :: FilterableWithIndex i t => (i -> a -> Bool) -> t a -> t a

-- | Indexed variant of <a>Witherable</a>.
class (TraversableWithIndex i t, Witherable t) => WitherableWithIndex i t | t -> i

-- | Effectful <a>imapMaybe</a>.
--   
--   <pre>
--   <a>iwither</a> ( i -&gt; <a>pure</a> . f i) ≡ <a>pure</a> . <a>imapMaybe</a> f
--   </pre>
iwither :: (WitherableWithIndex i t, Applicative f) => (i -> a -> f (Maybe b)) -> t a -> f (t b)

-- | <pre>
--   Monadic variant of <a>wither</a>. This may have more efficient implementation.
--   </pre>
iwitherM :: (WitherableWithIndex i t, Monad m) => (i -> a -> m (Maybe b)) -> t a -> m (t b)
ifilterA :: (WitherableWithIndex i t, Applicative f) => (i -> a -> f Bool) -> t a -> f (t a)

-- | This type allows combinators to take a <a>Filter</a> specializing the
--   parameter <tt>f</tt>.
type FilterLike f s t a b = (a -> f (Maybe b)) -> s -> f t

-- | A <a>Filter</a> is like a <a>Traversal</a>, but you can also remove
--   targets.
type Filter s t a b = forall f. Applicative f => FilterLike f s t a b

-- | A simple <a>FilterLike</a>.
type FilterLike' f s a = FilterLike f s s a a

-- | A simple <a>Filter</a>.
type Filter' s a = forall f. Applicative f => FilterLike' f s a

-- | <a>witherOf</a> is actually <a>id</a>, but left for consistency.
witherOf :: FilterLike f s t a b -> (a -> f (Maybe b)) -> s -> f t

-- | <pre>
--   <a>forMaybeOf</a> ≡ <a>flip</a>
--   </pre>
forMaybeOf :: FilterLike f s t a b -> s -> (a -> f (Maybe b)) -> f t

-- | <a>mapMaybe</a> through a filter.
mapMaybeOf :: FilterLike Identity s t a b -> (a -> Maybe b) -> s -> t

-- | <a>catMaybes</a> through a filter.
catMaybesOf :: FilterLike Identity s t (Maybe a) a -> s -> t

-- | <a>filterA</a> through a filter.
filterAOf :: Functor f => FilterLike' f s a -> (a -> f Bool) -> s -> f s

-- | Filter each element of a structure targeted by a <a>Filter</a>.
filterOf :: FilterLike' Identity s a -> (a -> Bool) -> s -> s

-- | Remove the duplicate elements through a filter.
ordNubOf :: Ord a => FilterLike' (State (Set a)) s a -> s -> s

-- | Remove the duplicate elements through a filter. It is often faster
--   than <a>ordNubOf</a>, especially when the comparison is expensive.
hashNubOf :: (Eq a, Hashable a) => FilterLike' (State (HashSet a)) s a -> s -> s

-- | Reconstitute a <a>Filter</a> from its monomorphic form.
cloneFilter :: FilterLike (Peat a b) s t a b -> Filter s t a b

-- | This is used to characterize and clone a <a>Filter</a>. Since
--   <tt>FilterLike (Peat a b) s t a b</tt> is monomorphic, it can be used
--   to store a filter in a container.
newtype Peat a b t
Peat :: (forall f. Applicative f => (a -> f (Maybe b)) -> f t) -> Peat a b t
[runPeat] :: Peat a b t -> forall f. Applicative f => (a -> f (Maybe b)) -> f t
instance GHC.Base.Alternative f => GHC.Base.Alternative (Data.Witherable.WrappedFoldable f)
instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Witherable.WrappedFoldable f)
instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Data.Witherable.WrappedFoldable f)
instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Data.Witherable.WrappedFoldable f)
instance GHC.Base.Functor f => GHC.Base.Functor (Data.Witherable.WrappedFoldable f)
instance Control.Lens.Indexed.FunctorWithIndex i f => Control.Lens.Indexed.FunctorWithIndex i (Data.Witherable.WrappedFoldable f)
instance Control.Lens.Indexed.FoldableWithIndex i f => Control.Lens.Indexed.FoldableWithIndex i (Data.Witherable.WrappedFoldable f)
instance Control.Lens.Indexed.TraversableWithIndex i f => Control.Lens.Indexed.TraversableWithIndex i (Data.Witherable.WrappedFoldable f)
instance (Data.Foldable.Foldable f, GHC.Base.Alternative f) => Data.Witherable.Filterable (Data.Witherable.WrappedFoldable f)
instance (Control.Lens.Indexed.FunctorWithIndex i f, Control.Lens.Indexed.FoldableWithIndex i f, GHC.Base.Alternative f) => Data.Witherable.FilterableWithIndex i (Data.Witherable.WrappedFoldable f)
instance (GHC.Base.Alternative f, Data.Traversable.Traversable f) => Data.Witherable.Witherable (Data.Witherable.WrappedFoldable f)
instance Data.Witherable.WitherableWithIndex () GHC.Maybe.Maybe
instance Data.Witherable.WitherableWithIndex GHC.Types.Int []
instance Data.Witherable.WitherableWithIndex GHC.Types.Int Data.IntMap.Internal.IntMap
instance Data.Witherable.WitherableWithIndex k (Data.Map.Internal.Map k)
instance Data.Witherable.WitherableWithIndex k (Data.Map.Monoidal.MonoidalMap k)
instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Witherable.WitherableWithIndex k (Data.HashMap.Base.HashMap k)
instance Data.Witherable.WitherableWithIndex Data.Void.Void Data.Proxy.Proxy
instance Data.Witherable.WitherableWithIndex GHC.Types.Int Data.Vector.Vector
instance Data.Witherable.WitherableWithIndex GHC.Types.Int Data.Sequence.Internal.Seq
instance (Control.Lens.Indexed.TraversableWithIndex i f, Data.Witherable.WitherableWithIndex j g) => Data.Witherable.WitherableWithIndex (i, j) (Data.Functor.Compose.Compose f g)
instance (Data.Witherable.WitherableWithIndex i f, Data.Witherable.WitherableWithIndex j g) => Data.Witherable.WitherableWithIndex (Data.Either.Either i j) (Data.Functor.Product.Product f g)
instance (Data.Witherable.WitherableWithIndex i f, Data.Witherable.WitherableWithIndex j g) => Data.Witherable.WitherableWithIndex (Data.Either.Either i j) (Data.Functor.Sum.Sum f g)
instance Data.Witherable.WitherableWithIndex i f => Data.Witherable.WitherableWithIndex i (Control.Monad.Trans.Identity.IdentityT f)
instance Data.Witherable.Witherable GHC.Maybe.Maybe
instance GHC.Base.Monoid e => Data.Witherable.Witherable (Data.Either.Either e)
instance Data.Witherable.Witherable []
instance Data.Witherable.Witherable Data.IntMap.Internal.IntMap
instance Data.Witherable.Witherable (Data.Map.Internal.Map k)
instance Data.Witherable.Witherable (Data.Map.Monoidal.MonoidalMap k)
instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Witherable.Witherable (Data.HashMap.Base.HashMap k)
instance Data.Witherable.Witherable Data.Proxy.Proxy
instance Data.Witherable.Witherable (Data.Functor.Const.Const r)
instance Data.Witherable.Witherable Data.Vector.Vector
instance Data.Witherable.Witherable Data.Sequence.Internal.Seq
instance (Data.Traversable.Traversable f, Data.Witherable.Witherable g) => Data.Witherable.Witherable (Data.Functor.Compose.Compose f g)
instance (Data.Witherable.Witherable f, Data.Witherable.Witherable g) => Data.Witherable.Witherable (Data.Functor.Product.Product f g)
instance (Data.Witherable.Witherable f, Data.Witherable.Witherable g) => Data.Witherable.Witherable (Data.Functor.Sum.Sum f g)
instance Data.Witherable.Witherable f => Data.Witherable.Witherable (Control.Monad.Trans.Identity.IdentityT f)
instance Data.Traversable.Traversable t => Data.Witherable.Witherable (Control.Monad.Trans.Maybe.MaybeT t)
instance Data.Witherable.FilterableWithIndex () GHC.Maybe.Maybe
instance Data.Witherable.FilterableWithIndex GHC.Types.Int []
instance Data.Witherable.FilterableWithIndex GHC.Types.Int Data.IntMap.Internal.IntMap
instance Data.Witherable.FilterableWithIndex k (Data.Map.Internal.Map k)
instance Data.Witherable.FilterableWithIndex k (Data.Map.Monoidal.MonoidalMap k)
instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Witherable.FilterableWithIndex k (Data.HashMap.Base.HashMap k)
instance Data.Witherable.FilterableWithIndex Data.Void.Void Data.Proxy.Proxy
instance Data.Witherable.FilterableWithIndex GHC.Types.Int Data.Vector.Vector
instance Data.Witherable.FilterableWithIndex GHC.Types.Int Data.Sequence.Internal.Seq
instance (Control.Lens.Indexed.FunctorWithIndex i f, Data.Witherable.FilterableWithIndex j g) => Data.Witherable.FilterableWithIndex (i, j) (Data.Functor.Compose.Compose f g)
instance (Data.Witherable.FilterableWithIndex i f, Data.Witherable.FilterableWithIndex j g) => Data.Witherable.FilterableWithIndex (Data.Either.Either i j) (Data.Functor.Product.Product f g)
instance (Data.Witherable.FilterableWithIndex i f, Data.Witherable.FilterableWithIndex j g) => Data.Witherable.FilterableWithIndex (Data.Either.Either i j) (Data.Functor.Sum.Sum f g)
instance Data.Witherable.FilterableWithIndex i f => Data.Witherable.FilterableWithIndex i (Control.Monad.Trans.Identity.IdentityT f)
instance Data.Witherable.Filterable GHC.Maybe.Maybe
instance GHC.Base.Monoid e => Data.Witherable.Filterable (Data.Either.Either e)
instance Data.Witherable.Filterable []
instance Data.Witherable.Filterable Data.IntMap.Internal.IntMap
instance Data.Witherable.Filterable (Data.Map.Internal.Map k)
instance Data.Witherable.Filterable (Data.Map.Monoidal.MonoidalMap k)
instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Witherable.Filterable (Data.HashMap.Base.HashMap k)
instance Data.Witherable.Filterable Data.Proxy.Proxy
instance Data.Witherable.Filterable (Data.Functor.Const.Const r)
instance Data.Witherable.Filterable Data.Vector.Vector
instance Data.Witherable.Filterable Data.Sequence.Internal.Seq
instance (GHC.Base.Functor f, Data.Witherable.Filterable g) => Data.Witherable.Filterable (Data.Functor.Compose.Compose f g)
instance (Data.Witherable.Filterable f, Data.Witherable.Filterable g) => Data.Witherable.Filterable (Data.Functor.Product.Product f g)
instance (Data.Witherable.Filterable f, Data.Witherable.Filterable g) => Data.Witherable.Filterable (Data.Functor.Sum.Sum f g)
instance Data.Witherable.Filterable f => Data.Witherable.Filterable (Control.Monad.Trans.Identity.IdentityT f)
instance GHC.Base.Functor f => Data.Witherable.Filterable (Control.Monad.Trans.Maybe.MaybeT f)
instance GHC.Base.Functor (Data.Witherable.Peat a b)
instance GHC.Base.Applicative (Data.Witherable.Peat a b)