Copyright	(c) Conal Elliott 2007
License	BSD3
Maintainer	conal@conal.net
Stability	experimental
Portability	GHC
Safe Haskell	None
Language	Haskell98

Data.Zip

Contents

Zippings
Unzipings
Dual unzipings
Misc

Description

Zip-related type constructor classes.

This module is similar to Control.Functor.Zip in the category-extras package, but it does not require a Functor superclass.

This module defines generalized zip and unzip, so if you use it, you'll have to

   import Prelude hiding (zip,zipWith,zipWith3,unzip)

Temporarily, there is also Data.Pair, which contains the same functionality with different naming. I'm unsure which I prefer.

Synopsis

Zippings

type ZipTy f = forall a b. f a -> f b -> f (a, b) Source #

Type of zip method

class Zip f where Source #

Type constructor class for zip-like things. Here are some standard instance templates you can fill in. They're not defined in the general forms below, because they would lead to a lot of overlap.

   instance Applicative f => Zip f where
       zip = liftA2 (,)
   instance (Applicative h, Zip f) => Zip (h :. f) where
       zip = apZip
   instance (Functor g, Zip g, Zip f) => Zip (g :. f)
       where zip = ppZip
   instance (Arrow (~>), Unzip f, Zip g) => Zip (Arrw (~>) f g) where
       zip = arZip
   instance (Monoid_f h, Cozip h) => Zip h where
       zip = cozip

Also, if you have a type constructor that's a Functor and a Zip, here is a way to define '(*)' for Applicative:

   (<*>) = zipWith ($)

Minimum definitions for instances.

Minimal complete definition

zip

Methods

zip :: ZipTy f Source #

Instances

Zip [] Source #
Methods zip :: ZipTy [] Source #
Zip IO Source #
Methods zip :: ZipTy IO Source #
Zip Endo Source #
Methods zip :: ZipTy Endo Source #
Zip Id Source #
Methods zip :: ZipTy Id Source #
Zip ((->) u) Source #
Methods zip :: ZipTy ((->) u) Source #
Monoid u => Zip ((,) u) Source #
Methods zip :: ZipTy ((,) u) Source #
Monoid o => Zip (Const * o) Source #
Methods zip :: ZipTy (Const * o) Source #
(Zip f, Zip g) => Zip ((:*:) f g) Source #
Methods zip :: ZipTy (f :*: g) Source #
(Arrow j, Monoid_f (Flip j o)) => Zip (Flip j o) Source #
Methods zip :: ZipTy (Flip j o) Source #
(Arrow j, Unzip f, Zip g) => Zip (Arrw j f g) Source #
Methods zip :: ZipTy (Arrw j f g) Source #

zipWith :: (Functor f, Zip f) => (a -> b -> c) -> f a -> f b -> f c Source #

Generalized zipWith

zipWith3 :: (Functor f, Zip f) => (a -> b -> c -> d) -> f a -> f b -> f c -> f d Source #

Generalized zipWith

apZip :: (Applicative h, Zip f) => ZipTy (h :. f) Source #

Handy for Zip instances

ppZip :: (Functor g, Zip g, Zip f) => ZipTy (g :. f) Source #

Handy for Zip instances

arZip :: (Arrow j, Unzip f, Zip g) => ZipTy (Arrw j f g) Source #

Ziping of Arrw values. Warning: definition uses arr, so only use if your arrow has a working arr.

Unzipings

type UnzipTy f = forall a b. f (a, b) -> (f a, f b) Source #

Type of unzip method. Generalizes unzip.

class Unzip f where Source #

Unzippable. Minimal instance definition: either (a) unzip or (b) both of fsts and snds. A standard template to substitute any Functor f. But watch out for effects!

    instance Functor f => Unzip f where {fsts = fmap fst; snds = fmap snd}

Methods

unzip :: UnzipTy f Source #

fsts :: f (a, b) -> f a Source #

snds :: f (a, b) -> f b Source #

Instances

Unzip [] Source #
Methods unzip :: UnzipTy [] Source # fsts :: [(a, b)] -> [a] Source # snds :: [(a, b)] -> [b] Source #
Unzip Endo Source #
Methods unzip :: UnzipTy Endo Source # fsts :: Endo (a, b) -> Endo a Source # snds :: Endo (a, b) -> Endo b Source #
Unzip Id Source #
Methods unzip :: UnzipTy Id Source # fsts :: Id (a, b) -> Id a Source # snds :: Id (a, b) -> Id b Source #
Unzip ((->) a) Source #
Methods unzip :: UnzipTy ((->) a) Source # fsts :: (a -> (a, b)) -> a -> a Source # snds :: (a -> (a, b)) -> a -> b Source #
Unzip ((,) a) Source #
Methods unzip :: UnzipTy ((,) a) Source # fsts :: (a, (a, b)) -> (a, a) Source # snds :: (a, (a, b)) -> (a, b) Source #
Unzip (Const * a) Source #
Methods unzip :: UnzipTy (Const * a) Source # fsts :: Const * a (a, b) -> Const * a a Source # snds :: Const * a (a, b) -> Const * a b Source #

Dual unzipings

class Cozip f where Source #

Dual to Unzip. Especially handy for contravariant functors (Cofunctor) . Use this template (filling in f) :

   instance Cofunctor f => Cozip f where
     { cofsts = cofmap fst ; cosnds = cofmap snd }

Minimal complete definition

cofsts, cosnds

Methods

cofsts :: f a -> f (a, b) Source #

cosnds :: f b -> f (a, b) Source #

Instances

Cozip Endo Source #
Methods cofsts :: Endo a -> Endo (a, b) Source # cosnds :: Endo b -> Endo (a, b) Source #
Cozip (Const * e) Source #
Methods cofsts :: Const * e a -> Const * e (a, b) Source # cosnds :: Const * e b -> Const * e (a, b) Source #
(Cozip f, Cozip g) => Cozip ((:*:) f g) Source #
Methods cofsts :: (f :: g) a -> (f :: g) (a, b) Source # cosnds :: (f :: g) b -> (f :: g) (a, b) Source #
Arrow j => Cozip (Flip j o) Source #
Methods cofsts :: Flip j o a -> Flip j o (a, b) Source # cosnds :: Flip j o b -> Flip j o (a, b) Source #
(Functor h, Cozip f) => Cozip ((:.) h f) Source #
Methods cofsts :: (h :. f) a -> (h :. f) (a, b) Source # cosnds :: (h :. f) b -> (h :. f) (a, b) Source #

cozip :: (Cozip f, Monoid_f f) => ZipTy f Source #

Ziping of Cozip values. Combines contribution of each.

Misc

pairEdit :: (Functor m, Monoid (m ((c, d) -> (c, d)))) => (m c, m d) -> m ((c, d) -> (c, d)) Source #

Turn a pair of sources into a source of pair-editors. See http://conal.net/blog/posts/pairs-sums-and-reactivity/. 'Functor'\/'Monoid' version. See also pairEditM.

pairEditM :: MonadPlus m => (m c, m d) -> m ((c, d) -> (c, d)) Source #

Turn a pair of sources into a source of pair-editors. See http://conal.net/blog/posts/pairs-sums-and-reactivity/. Monad version. See also pairEdit.