W3cubDocs

/Haskell 8

Control.Monad.Zip

Copyright	(c) Nils Schweinsberg 2011, (c) George Giorgidze 2011 (c) University Tuebingen 2011
License	BSD-style (see the file libraries/base/LICENSE)
Maintainer	[email protected]
Stability	experimental
Portability	portable
Safe Haskell	Safe
Language	Haskell2010

Description

Monadic zipping (used for monad comprehensions)

class Monad m => MonadZip m where Source

MonadZip type class. Minimal definition: mzip or mzipWith

Instances should satisfy the laws:

Naturality :

liftM (f *** g) (mzip ma mb) = mzip (liftM f ma) (liftM g mb)

Information Preservation:

liftM (const ()) ma = liftM (const ()) mb
==>
munzip (mzip ma mb) = (ma, mb)

Minimal complete definition

mzip | mzipWith

Methods

mzip :: m a -> m b -> m (a, b) Source

mzipWith :: (a -> b -> c) -> m a -> m b -> m c Source

munzip :: m (a, b) -> (m a, m b) Source

Instances

MonadZip []
Methods mzip :: [a] -> [b] -> [(a, b)] Source mzipWith :: (a -> b -> c) -> [a] -> [b] -> [c] Source munzip :: [(a, b)] -> ([a], [b]) Source
MonadZip Maybe
Methods mzip :: Maybe a -> Maybe b -> Maybe (a, b) Source mzipWith :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c Source munzip :: Maybe (a, b) -> (Maybe a, Maybe b) Source
MonadZip U1
Methods mzip :: U1 a -> U1 b -> U1 (a, b) Source mzipWith :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source munzip :: U1 (a, b) -> (U1 a, U1 b) Source
MonadZip Par1
Methods mzip :: Par1 a -> Par1 b -> Par1 (a, b) Source mzipWith :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c Source munzip :: Par1 (a, b) -> (Par1 a, Par1 b) Source
MonadZip Last
Methods mzip :: Last a -> Last b -> Last (a, b) Source mzipWith :: (a -> b -> c) -> Last a -> Last b -> Last c Source munzip :: Last (a, b) -> (Last a, Last b) Source
MonadZip First
Methods mzip :: First a -> First b -> First (a, b) Source mzipWith :: (a -> b -> c) -> First a -> First b -> First c Source munzip :: First (a, b) -> (First a, First b) Source
MonadZip Product
Methods mzip :: Product a -> Product b -> Product (a, b) Source mzipWith :: (a -> b -> c) -> Product a -> Product b -> Product c Source munzip :: Product (a, b) -> (Product a, Product b) Source
MonadZip Sum
Methods mzip :: Sum a -> Sum b -> Sum (a, b) Source mzipWith :: (a -> b -> c) -> Sum a -> Sum b -> Sum c Source munzip :: Sum (a, b) -> (Sum a, Sum b) Source
MonadZip Dual
Methods mzip :: Dual a -> Dual b -> Dual (a, b) Source mzipWith :: (a -> b -> c) -> Dual a -> Dual b -> Dual c Source munzip :: Dual (a, b) -> (Dual a, Dual b) Source
MonadZip NonEmpty
Methods mzip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b) Source mzipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source munzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b) Source
MonadZip Identity
Methods mzip :: Identity a -> Identity b -> Identity (a, b) Source mzipWith :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source munzip :: Identity (a, b) -> (Identity a, Identity b) Source
MonadZip f => MonadZip (Rec1 f)
Methods mzip :: Rec1 f a -> Rec1 f b -> Rec1 f (a, b) Source mzipWith :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c Source munzip :: Rec1 f (a, b) -> (Rec1 f a, Rec1 f b) Source
MonadZip (Proxy *)
Methods mzip :: Proxy * a -> Proxy * b -> Proxy * (a, b) Source mzipWith :: (a -> b -> c) -> Proxy * a -> Proxy * b -> Proxy * c Source munzip :: Proxy * (a, b) -> (Proxy * a, Proxy * b) Source
(MonadZip f, MonadZip g) => MonadZip ((:*:) f g)
Methods mzip :: (f :: g) a -> (f :: g) b -> (f :: g) (a, b) Source mzipWith :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c Source munzip :: (f :: g) (a, b) -> ((f :: g) a, (f :*: g) b) Source
MonadZip f => MonadZip (Alt * f)
Methods mzip :: Alt * f a -> Alt * f b -> Alt * f (a, b) Source mzipWith :: (a -> b -> c) -> Alt * f a -> Alt * f b -> Alt * f c Source munzip :: Alt * f (a, b) -> (Alt * f a, Alt * f b) Source
MonadZip f => MonadZip (M1 i c f)
Methods mzip :: M1 i c f a -> M1 i c f b -> M1 i c f (a, b) Source mzipWith :: (a -> b -> c) -> M1 i c f a -> M1 i c f b -> M1 i c f c Source munzip :: M1 i c f (a, b) -> (M1 i c f a, M1 i c f b) Source
(MonadZip f, MonadZip g) => MonadZip (Product * f g)
Methods mzip :: Product * f g a -> Product * f g b -> Product * f g (a, b) Source mzipWith :: (a -> b -> c) -> Product * f g a -> Product * f g b -> Product * f g c Source munzip :: Product * f g (a, b) -> (Product * f g a, Product * f g b) Source

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.0.1/docs/html/libraries/base-4.9.0.0/Control-Monad-Zip.html