Data.Align

These-based zipping and unzipping of functors with non-uniform shapes, plus traversal of (bi)foldable (bi)functors through said functors.

Documentation

class Functor f => Align f where

Functors supporting a zip operation that takes the union of non-uniform shapes.

If your functor is actually a functor from Kleisli Maybe to Hask (so it supports maybeMap :: (a -> Maybe b) -> f a -> f b), then an Align instance is making your functor lax monoidal w.r.t. the cartesian monoidal structure on Kleisli Maybe, because These is the cartesian product in that category (a -> Maybe (These b c) ~ (a -> Maybe b, a -> Maybe c)). This insight is due to rwbarton.

Minimal definition: nil and either align or alignWith.

Laws:

(`align` nil) = fmap This
(nil `align`) = fmap That
join align = fmap (join These)
align (f <$> x) (g <$> y) = bimap f g <$> align x y
alignWith f a b = f <$> align a b

Minimal complete definition

nil, (align | alignWith)

Methods

nil :: f a

An empty strucutre. aligning with nil will produce a structure with the same shape and elements as the other input, modulo This or That.

align :: f a -> f b -> f (These a b)

Analogous to zip, combines two structures by taking the union of their shapes and using These to hold the elements.

alignWith :: (These a b -> c) -> f a -> f b -> f c

Analogous to zipWith, combines two structures by taking the union of their shapes and combining the elements with the given function.

Instances

Align []

Methods

nil :: [a]

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

alignWith :: (These a b -> c) -> [a] -> [b] -> [c]

Align Maybe

Methods

nil :: Maybe a

align :: Maybe a -> Maybe b -> Maybe (These a b)

alignWith :: (These a b -> c) -> Maybe a -> Maybe b -> Maybe c

Align ZipList

Methods

nil :: ZipList a

align :: ZipList a -> ZipList b -> ZipList (These a b)

alignWith :: (These a b -> c) -> ZipList a -> ZipList b -> ZipList c

Align IntMap

Methods

nil :: IntMap a

align :: IntMap a -> IntMap b -> IntMap (These a b)

alignWith :: (These a b -> c) -> IntMap a -> IntMap b -> IntMap c

Align Seq

Methods

nil :: Seq a

align :: Seq a -> Seq b -> Seq (These a b)

alignWith :: (These a b -> c) -> Seq a -> Seq b -> Seq c

Align Vector

Methods

nil :: Vector a

align :: Vector a -> Vector b -> Vector (These a b)

alignWith :: (These a b -> c) -> Vector a -> Vector b -> Vector c

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

Methods

nil :: HashMap k a

align :: HashMap k a -> HashMap k b -> HashMap k (These a b)

alignWith :: (These a b -> c) -> HashMap k a -> HashMap k b -> HashMap k c

Ord k => Align (Map k)

Methods

nil :: Map k a

align :: Map k a -> Map k b -> Map k (These a b)

alignWith :: (These a b -> c) -> Map k a -> Map k b -> Map k c

Monad m => Align (Stream m)

Methods

nil :: Stream m a

align :: Stream m a -> Stream m b -> Stream m (These a b)

alignWith :: (These a b -> c) -> Stream m a -> Stream m b -> Stream m c

Monad m => Align (Bundle m v)

Methods

nil :: Bundle m v a

align :: Bundle m v a -> Bundle m v b -> Bundle m v (These a b)

alignWith :: (These a b -> c) -> Bundle m v a -> Bundle m v b -> Bundle m v c

(Align f, Align g) => Align (Product * f g)

Methods

nil :: Product * f g a

align :: Product * f g a -> Product * f g b -> Product * f g (These a b)

alignWith :: (These a b -> c) -> Product * f g a -> Product * f g b -> Product * f g c

Specialized aligns

malign :: (Align f, Monoid a) => f a -> f a -> f a

Align two structures and combine with mappend.

padZip :: Align f => f a -> f b -> f (Maybe a, Maybe b)

Align two structures as in zip, but filling in blanks with Nothing.

padZipWith :: Align f => (Maybe a -> Maybe b -> c) -> f a -> f b -> f c

Align two structures as in zipWith, but filling in blanks with Nothing.

lpadZip :: [a] -> [b] -> [(Maybe a, b)]

Left-padded zip.

lpadZipWith :: (Maybe a -> b -> c) -> [a] -> [b] -> [c]

Left-padded zipWith.

rpadZip :: [a] -> [b] -> [(a, Maybe b)]

Right-padded zip.

rpadZipWith :: (a -> Maybe b -> c) -> [a] -> [b] -> [c]

Right-padded zipWith.

alignVectorWith :: (Vector v a, Vector v b, Vector v c) => (These a b -> c) -> v a -> v b -> v c

Unalign

class Align f => Unalign f where

Alignable functors supporting an "inverse" to align: splitting a union shape into its component parts.

Minimal definition: nothing; a default definition is provided, but it may not have the desired definition for all functors. See the source for more information.

Laws:

unalign nil                 = (nil,           nil)
unalign (This        <$> x) = (Just    <$> x, Nothing <$  x)
unalign (That        <$> y) = (Nothing <$  y, Just    <$> y)
unalign (join These  <$> x) = (Just    <$> x, Just    <$> x)
unalign ((x `These`) <$> y) = (Just x  <$  y, Just    <$> y)
unalign ((`These` y) <$> x) = (Just    <$> x, Just y  <$  x)

Methods

unalign :: f (These a b) -> (f (Maybe a), f (Maybe b))

Instances

Unalign []

Methods

unalign :: [These a b] -> ([Maybe a], [Maybe b])

Unalign Maybe

Methods

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

Unalign ZipList

Methods

unalign :: ZipList (These a b) -> (ZipList (Maybe a), ZipList (Maybe b))

Monad m => Unalign (Stream m)

Methods

unalign :: Stream m (These a b) -> (Stream m (Maybe a), Stream m (Maybe b))

(Unalign f, Unalign g) => Unalign (Product * f g)

Methods

unalign :: Product * f g (These a b) -> (Product * f g (Maybe a), Product * f g (Maybe b))

Crosswalk

class (Functor t, Foldable t) => Crosswalk t where

Foldable functors supporting traversal through an alignable functor.

Minimal definition: crosswalk or sequenceL.

Laws:

crosswalk (const nil) = const nil
crosswalk f = sequenceL . fmap f

Minimal complete definition

crosswalk | sequenceL

Methods

crosswalk :: Align f => (a -> f b) -> t a -> f (t b)

sequenceL :: Align f => t (f a) -> f (t a)

Instances

Crosswalk []

Methods

crosswalk :: Align f => (a -> f b) -> [a] -> f [b]

sequenceL :: Align f => [f a] -> f [a]

Crosswalk Maybe

Methods

crosswalk :: Align f => (a -> f b) -> Maybe a -> f (Maybe b)

sequenceL :: Align f => Maybe (f a) -> f (Maybe a)

Crosswalk Identity

Methods

crosswalk :: Align f => (a -> f b) -> Identity a -> f (Identity b)

sequenceL :: Align f => Identity (f a) -> f (Identity a)

Crosswalk Seq

Methods

crosswalk :: Align f => (a -> f b) -> Seq a -> f (Seq b)

sequenceL :: Align f => Seq (f a) -> f (Seq a)

Crosswalk Vector

Methods

crosswalk :: Align f => (a -> f b) -> Vector a -> f (Vector b)

sequenceL :: Align f => Vector (f a) -> f (Vector a)

Crosswalk (These a)

Methods

crosswalk :: Align f => (a -> f b) -> These a a -> f (These a b)

sequenceL :: Align f => These a (f a) -> f (These a a)

Bicrosswalk

class (Bifunctor t, Bifoldable t) => Bicrosswalk t where

Bifoldable bifunctors supporting traversal through an alignable functor.

Minimal definition: bicrosswalk or bisequenceL.

Laws:

bicrosswalk (const empty) (const empty) = const empty
bicrosswalk f g = bisequenceL . bimap f g

Minimal complete definition

bicrosswalk | bisequenceL

Methods

bicrosswalk :: Align f => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)

bisequenceL :: Align f => t (f a) (f b) -> f (t a b)

Instances

Bicrosswalk Either

Methods

bicrosswalk :: Align f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d)

bisequenceL :: Align f => Either (f a) (f b) -> f (Either a b)

Bicrosswalk These

Methods

bicrosswalk :: Align f => (a -> f c) -> (b -> f d) -> These a b -> f (These c d)

bisequenceL :: Align f => These (f a) (f b) -> f (These a b)