Witherable

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

Formally, the class Filterable represents a functor from Kleisli Maybe to Hask.

A definition of mapMaybe must satisfy the following laws:

conservation

mapMaybe (Just . f) ≡ fmap f

composition

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

An infix alias for mapMaybe. The name of the operator alludes to <$>, and has the same fixity.

Flipped version of <$?>, the Filterable version of <&>. It has the same fixity as <&>.

(<&?>) = flip mapMaybe

An enhancement of Traversable with Filterable

A definition of wither must satisfy the following laws:

identity

wither (Data.Functor.Identity . Just) ≡ Data.Functor.Identity

composition

Compose . fmap (wither f) . wither g ≡ wither (Compose . fmap (wither f) . g)

Parametricity implies the naturality law:

naturality

t . wither f ≡ wither (t . f)

Where t is an /applicative transformation/ in the sense described in the Traversable documentation.

In the relation to superclasses, these should satisfy too:

conservation

wither (fmap Just . f) = traverse f

pure filter

wither (Data.Functor.Identity . f) = Data.Functor.Identity . mapMaybe f

See the Properties.md and Laws.md files in the git distribution for more in-depth explanation about properties of Witherable containers.

The laws and restrictions are enough to constrain wither to be uniquely determined as the following default implementation.

wither f = fmap catMaybes . traverse f

If not to provide better-performing implementation, it's not necessary to implement any one method of Witherable. For example, if a type constructor T already has instances of Traversable and Filterable, the next one line is sufficient to provide the Witherable T instance.

instance Witherable T

Removes duplicate elements from a list, keeping only the first occurrence. This is asymptotically faster than using nub from Data.List.

>>> ordNub [3,2,1,3,2,1][3,2,1]

The ordNubOn function behaves just like ordNub, except it uses a another type to determine equivalence classes.

>>> ordNubOn fst [(True, 'x'), (False, 'y'), (True, 'z')][(True,'x'),(False,'y')]

Removes duplicate elements from a list, keeping only the first occurrence. This is usually faster than ordNub, especially for things that have a slow comparison (like String).

>>> hashNub [3,2,1,3,2,1][3,2,1]

The hashNubOn function behaves just like hashNub, except it uses a another type to determine equivalence classes.

>>> hashNubOn fst [(True, 'x'), (False, 'y'), (True, 'z')][(True,'x'),(False,'y')]

Indexed variant of Filterable.

Indexed variant of Witherable.