Data.These

The These type and associated operations. Now enhanced with Control.Lens magic!

Documentation

data These a b

The These type represents values with two non-exclusive possibilities.

This can be useful to represent combinations of two values, where the combination is defined if either input is. Algebraically, the type These A B represents (A + B + AB), which doesn't factor easily into sums and products--a type like Either A (B, Maybe A) is unclear and awkward to use.

These has straightforward instances of Functor, Monad, &c., and behaves like a hybrid error/writer monad, as would be expected.

Constructors

This a

That b

These a b

Instances

Bitraversable1 These

Bitraversable These

Bifunctor These

Bifoldable1 These

Bifoldable These

Bicrosswalk These

(Monad (These c), Monoid c) => MonadChronicle c (These c)

Monoid a => Monad (These a)

Functor (These a)

(Functor (These a), Monoid a) => Applicative (These a)

Foldable (These a)

(Functor (These a), Foldable (These a)) => Traversable (These a)

(Functor (These a), Monoid a) => Apply (These a)

(Apply (These a), Monoid a) => Bind (These a)

(Functor (These a), Foldable (These a)) => Crosswalk (These a)

(Eq a, Eq b) => Eq (These a b)

(Eq (These a b), Ord a, Ord b) => Ord (These a b)

(Read a, Read b) => Read (These a b)

(Show a, Show b) => Show (These a b)

(Semigroup a, Semigroup b) => Semigroup (These a b)

Functions to get rid of These

these :: (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c

Case analysis for the These type.

fromThese :: a -> b -> These a b -> (a, b)

Takes two default values and produces a tuple.

mergeThese :: (a -> a -> a) -> These a a -> a

Coalesce with the provided operation.

Traversals

here :: Applicative f => (a -> f b) -> These a t -> f (These b t)

A Traversal of the first half of a These, suitable for use with Control.Lens.

there :: Applicative f => (a -> f b) -> These t a -> f (These t b)

A Traversal of the second half of a These, suitable for use with Control.Lens.

Prisms

_This :: (Choice p, Applicative f) => p a (f a) -> p (These a b) (f (These a b))

A Prism selecting the This constructor.

_That :: (Choice p, Applicative f) => p b (f b) -> p (These a b) (f (These a b))

A Prism selecting the That constructor.

_These :: (Choice p, Applicative f) => p (a, b) (f (a, b)) -> p (These a b) (f (These a b))

A Prism selecting the These constructor. These names are ridiculous!

Case selections

justThis :: These a b -> Maybe a

justThis = preview _This

justThat :: These a b -> Maybe b

justThat = preview _That

justThese :: These a b -> Maybe (a, b)

justThese = preview _These

catThis :: [These a b] -> [a]

Select all This constructors from a list.

catThat :: [These a b] -> [b]

Select all That constructors from a list.

catThese :: [These a b] -> [(a, b)]

Select all These constructors from a list.

partitionThese :: [These a b] -> ([(a, b)], ([a], [b]))

Select each constructor and partition them into separate lists.

Case predicates

isThis :: These a b -> Bool

isThis = isJust . justThis

isThat :: These a b -> Bool

isThat = isJust . justThat

isThese :: These a b -> Bool

isThese = isJust . justThese

Map operations

mapThese :: (a -> c) -> (b -> d) -> These a b -> These c d

Bifunctor map.

mapThis :: (a -> c) -> These a b -> These c b

mapThis = over here

mapThat :: (b -> d) -> These a b -> These a d

mapThat = over there

For zipping and unzipping of structures with These values, see Data.Align.