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 => Semialign 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: either align or alignWith.

Laws:

join align = fmap (join These)
align (f <$> x) (g <$> y) = bimap f g <$> align x y
alignWith f a b = f <$> align a b
align x (align y z) = fmap assoc (align (align x y) z)

Note: join f x = f x x

And an addition property if f is Foldable, which tries to enforce align-feel: neither values are duplicated nor lost.

toList x = toListOf (folded . here) (align x y)
         = mapMaybe justHere (toList (align x y))

Minimal complete definition

align | alignWith

Methods

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

Semialign []

Defined in Data.Align

Methods

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

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

Semialign Maybe

Defined in Data.Align

Methods

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

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

Semialign ZipList

Defined in Data.Align

Methods

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

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

Semialign Identity

Defined in Data.Align

Methods

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

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

Semialign NonEmpty

Defined in Data.Align

Methods

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

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

Semialign IntMap

Defined in Data.Align

Methods

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

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

Semialign Seq

Defined in Data.Align

Methods

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

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

Semialign Vector

Defined in Data.Align

Methods

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

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

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

Defined in Data.Align

Methods

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 => Semialign (Map k)

Defined in Data.Align

Methods

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 => Semialign (Stream m)

Defined in Data.Align

Methods

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 => Semialign (Bundle m v)

Defined in Data.Align

Methods

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

(Semialign f, Semialign g) => Semialign (Product f g)

Defined in Data.Align

Methods

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

class Semialign f => Align f where

A unit of align.

Laws:

(`align` nil) = fmap This
(nil `align`) = fmap That

Methods

nil :: f a

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

Instances

Align []

Defined in Data.Align

Methods

nil :: [a]

Align Maybe

Defined in Data.Align

Methods

nil :: Maybe a

Align ZipList

Defined in Data.Align

Methods

nil :: ZipList a

Align IntMap

Defined in Data.Align

Methods

nil :: IntMap a

Align Seq

Defined in Data.Align

Methods

nil :: Seq a

Align Vector

Defined in Data.Align

Methods

nil :: Vector a

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

Defined in Data.Align

Methods

nil :: HashMap k a

Ord k => Align (Map k)

Defined in Data.Align

Methods

nil :: Map k a

Monad m => Align (Stream m)

Defined in Data.Align

Methods

nil :: Stream m a

Monad m => Align (Bundle m v)

Defined in Data.Align

Methods

nil :: Bundle m v a

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

Defined in Data.Align

Methods

nil :: Product f g a

Specialized aligns

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

Align two structures and combine with mappend.

See salign. malign will be deprecated after Semigroup becomes a super class of Monoid

salign :: (Align f, Semigroup a) => f a -> f a -> f a

Align two structures and combine with <>.

Since: 0.7.3

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)

Minimal complete definition

Nothing

Methods

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

Instances

Unalign []

Defined in Data.Align

Methods

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

Unalign Maybe

Defined in Data.Align

Methods

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

Unalign ZipList

Defined in Data.Align

Methods

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

Monad m => Unalign (Stream m)

Defined in Data.Align

Methods

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

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

Defined in Data.Align

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 []

Defined in Data.Align

Methods

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

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

Crosswalk Maybe

Defined in Data.Align

Methods

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

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

Crosswalk Identity

Defined in Data.Align

Methods

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

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

Crosswalk Seq

Defined in Data.Align

Methods

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

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

Crosswalk Vector

Defined in Data.Align

Methods

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

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

Crosswalk ((,) a)

Since: 0.7.5

Defined in Data.Align

Methods

crosswalk :: Align f => (a0 -> f b) -> (a, a0) -> f (a, b)

sequenceL :: Align f => (a, f a0) -> f (a, a0)

Crosswalk (These a)

Defined in Data.Align

Methods

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

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

(Crosswalk f, Crosswalk g) => Crosswalk (Compose f g)

Since: 0.7.5

Defined in Data.Align

Methods

crosswalk :: Align f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b)

sequenceL :: Align f0 => Compose f g (f0 a) -> f0 (Compose f g 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

Defined in Data.Align

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

Defined in Data.Align

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)