Data.Witherable

Documentation

class Traversable t => Witherable t where

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

traverse f ≡ wither (fmap Just . f)

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)

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

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

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

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

Instances

Witherable []

Witherable Maybe

Witherable IntMap

Witherable Seq

Witherable Vector

Monoid e => Witherable (Either e)

Witherable (Const r)

Witherable (Proxy *)

Ord k => Witherable (Map k)

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

Traversable t => Witherable (Chipped t)

ordNub :: (Witherable t, Ord a) => t a -> t a

Removes duplicate elements from a list, keeping only the first occurrence. This is exponentially quicker than using nub from 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) hashNubOf :: (Witherable t, Eq a, Hashable a) => t a -> t a

Generalization

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

witherOf is actually id, but left for consistency.

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

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 (Dungeon a b) s t a b -> Filter s t a b

newtype Dungeon a b t

Constructors

Dungeon

Fields

runDungeon :: forall f. Applicative f => (a -> f (Maybe b)) -> f t

Instances

Functor (Dungeon a b)

Applicative (Dungeon a b)

Witherable from Traversable

newtype Chipped t a

Traversable containers which hold Maybe are witherable.

Constructors

Chipped

Fields

getChipped :: t (Maybe a)

Instances

Functor t => Functor (Chipped t)

Applicative t => Applicative (Chipped t)

Foldable t => Foldable (Chipped t)

Traversable t => Traversable (Chipped t)

Traversable t => Witherable (Chipped t)

Eq (t (Maybe a)) => Eq (Chipped t a)

Ord (t (Maybe a)) => Ord (Chipped t a)

Read (t (Maybe a)) => Read (Chipped t a)

Show (t (Maybe a)) => Show (Chipped t a)