Control.Subcategory.Zip

Documentation

class CSemialign f => CZip f where

Minimal complete definition

czipWith

Methods

czipWith :: (Dom f a, Dom f b, Dom f c) => (a -> b -> c) -> f a -> f b -> f c

czip :: (Dom f a, Dom f b, Dom f (a, b)) => f a -> f b -> f (a, b)

Instances

CZip []

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom [] a, Dom [] b, Dom [] c) => (a -> b -> c) -> [a] -> [b] -> [c]

czip :: (Dom [] a, Dom [] b, Dom [] (a, b)) => [a] -> [b] -> [(a, b)]

CZip Maybe

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Maybe a, Dom Maybe b, Dom Maybe c) => (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

czip :: (Dom Maybe a, Dom Maybe b, Dom Maybe (a, b)) => Maybe a -> Maybe b -> Maybe (a, b)

CZip Option

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Option a, Dom Option b, Dom Option c) => (a -> b -> c) -> Option a -> Option b -> Option c

czip :: (Dom Option a, Dom Option b, Dom Option (a, b)) => Option a -> Option b -> Option (a, b)

CZip ZipList

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom ZipList a, Dom ZipList b, Dom ZipList c) => (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

czip :: (Dom ZipList a, Dom ZipList b, Dom ZipList (a, b)) => ZipList a -> ZipList b -> ZipList (a, b)

CZip Identity

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Identity a, Dom Identity b, Dom Identity c) => (a -> b -> c) -> Identity a -> Identity b -> Identity c

czip :: (Dom Identity a, Dom Identity b, Dom Identity (a, b)) => Identity a -> Identity b -> Identity (a, b)

CZip NonEmpty

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom NonEmpty a, Dom NonEmpty b, Dom NonEmpty c) => (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

czip :: (Dom NonEmpty a, Dom NonEmpty b, Dom NonEmpty (a, b)) => NonEmpty a -> NonEmpty b -> NonEmpty (a, b)

CZip IntMap

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom IntMap a, Dom IntMap b, Dom IntMap c) => (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c

czip :: (Dom IntMap a, Dom IntMap b, Dom IntMap (a, b)) => IntMap a -> IntMap b -> IntMap (a, b)

CZip Tree

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Tree a, Dom Tree b, Dom Tree c) => (a -> b -> c) -> Tree a -> Tree b -> Tree c

czip :: (Dom Tree a, Dom Tree b, Dom Tree (a, b)) => Tree a -> Tree b -> Tree (a, b)

CZip Seq

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Seq a, Dom Seq b, Dom Seq c) => (a -> b -> c) -> Seq a -> Seq b -> Seq c

czip :: (Dom Seq a, Dom Seq b, Dom Seq (a, b)) => Seq a -> Seq b -> Seq (a, b)

CZip PrimArray

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom PrimArray a, Dom PrimArray b, Dom PrimArray c) => (a -> b -> c) -> PrimArray a -> PrimArray b -> PrimArray c

czip :: (Dom PrimArray a, Dom PrimArray b, Dom PrimArray (a, b)) => PrimArray a -> PrimArray b -> PrimArray (a, b)

CZip SmallArray

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom SmallArray a, Dom SmallArray b, Dom SmallArray c) => (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c

czip :: (Dom SmallArray a, Dom SmallArray b, Dom SmallArray (a, b)) => SmallArray a -> SmallArray b -> SmallArray (a, b)

CZip Array

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Array a, Dom Array b, Dom Array c) => (a -> b -> c) -> Array a -> Array b -> Array c

czip :: (Dom Array a, Dom Array b, Dom Array (a, b)) => Array a -> Array b -> Array (a, b)

CZip Vector

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Vector a, Dom Vector b, Dom Vector c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c

czip :: (Dom Vector a, Dom Vector b, Dom Vector (a, b)) => Vector a -> Vector b -> Vector (a, b)

CZip Vector

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Vector a, Dom Vector b, Dom Vector c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c

czip :: (Dom Vector a, Dom Vector b, Dom Vector (a, b)) => Vector a -> Vector b -> Vector (a, b)

CZip Vector

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Vector a, Dom Vector b, Dom Vector c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c

czip :: (Dom Vector a, Dom Vector b, Dom Vector (a, b)) => Vector a -> Vector b -> Vector (a, b)

CZip Vector

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Vector a, Dom Vector b, Dom Vector c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c

czip :: (Dom Vector a, Dom Vector b, Dom Vector (a, b)) => Vector a -> Vector b -> Vector (a, b)

CZip (Proxy :: Type -> Type)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom Proxy a, Dom Proxy b, Dom Proxy c) => (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

czip :: (Dom Proxy a, Dom Proxy b, Dom Proxy (a, b)) => Proxy a -> Proxy b -> Proxy (a, b)

Ord k => CZip (Map k)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (Map k) a, Dom (Map k) b, Dom (Map k) c) => (a -> b -> c) -> Map k a -> Map k b -> Map k c

czip :: (Dom (Map k) a, Dom (Map k) b, Dom (Map k) (a, b)) => Map k a -> Map k b -> Map k (a, b)

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

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (HashMap k) a, Dom (HashMap k) b, Dom (HashMap k) c) => (a -> b -> c) -> HashMap k a -> HashMap k b -> HashMap k c

czip :: (Dom (HashMap k) a, Dom (HashMap k) b, Dom (HashMap k) (a, b)) => HashMap k a -> HashMap k b -> HashMap k (a, b)

Zip f => CZip (WrapFunctor f)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (WrapFunctor f) a, Dom (WrapFunctor f) b, Dom (WrapFunctor f) c) => (a -> b -> c) -> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c

czip :: (Dom (WrapFunctor f) a, Dom (WrapFunctor f) b, Dom (WrapFunctor f) (a, b)) => WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)

(IsSequence mono, MonoZip mono) => CZip (WrapMono mono :: Type -> Type)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (WrapMono mono) a, Dom (WrapMono mono) b, Dom (WrapMono mono) c) => (a -> b -> c) -> WrapMono mono a -> WrapMono mono b -> WrapMono mono c

czip :: (Dom (WrapMono mono) a, Dom (WrapMono mono) b, Dom (WrapMono mono) (a, b)) => WrapMono mono a -> WrapMono mono b -> WrapMono mono (a, b)

CZip f => CZip (CZippy f)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (CZippy f) a, Dom (CZippy f) b, Dom (CZippy f) c) => (a -> b -> c) -> CZippy f a -> CZippy f b -> CZippy f c

czip :: (Dom (CZippy f) a, Dom (CZippy f) b, Dom (CZippy f) (a, b)) => CZippy f a -> CZippy f b -> CZippy f (a, b)

CZip ((->) e :: Type -> Type)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom ((->) e) a, Dom ((->) e) b, Dom ((->) e) c) => (a -> b -> c) -> (e -> a) -> (e -> b) -> e -> c

czip :: (Dom ((->) e) a, Dom ((->) e) b, Dom ((->) e) (a, b)) => (e -> a) -> (e -> b) -> e -> (a, b)

(CZip f, CZip g) => CZip (f :*: g)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (f :*: g) a, Dom (f :*: g) b, Dom (f :*: g) c) => (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c

czip :: (Dom (f :*: g) a, Dom (f :*: g) b, Dom (f :*: g) (a, b)) => (f :*: g) a -> (f :*: g) b -> (f :*: g) (a, b)

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

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (Product f g) a, Dom (Product f g) b, Dom (Product f g) c) => (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c

czip :: (Dom (Product f g) a, Dom (Product f g) b, Dom (Product f g) (a, b)) => Product f g a -> Product f g b -> Product f g (a, b)

(CZip f, CZip g) => CZip (f :.: g)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (f :.: g) a, Dom (f :.: g) b, Dom (f :.: g) c) => (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c

czip :: (Dom (f :.: g) a, Dom (f :.: g) b, Dom (f :.: g) (a, b)) => (f :.: g) a -> (f :.: g) b -> (f :.: g) (a, b)

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

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (Compose f g) a, Dom (Compose f g) b, Dom (Compose f g) c) => (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c

czip :: (Dom (Compose f g) a, Dom (Compose f g) b, Dom (Compose f g) (a, b)) => Compose f g a -> Compose f g b -> Compose f g (a, b)

class CZip f => CUnzip f where

Minimal complete definition

cunzipWith

Methods

cunzip :: (Dom f (a, b), Dom f a, Dom f b) => f (a, b) -> (f a, f b)

cunzipWith :: (Dom f c, Dom f a, Dom f b) => (c -> (a, b)) -> f c -> (f a, f b)

Instances

CUnzip []

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom [] (a, b), Dom [] a, Dom [] b) => [(a, b)] -> ([a], [b])

cunzipWith :: (Dom [] c, Dom [] a, Dom [] b) => (c -> (a, b)) -> [c] -> ([a], [b])

CUnzip Maybe

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Maybe (a, b), Dom Maybe a, Dom Maybe b) => Maybe (a, b) -> (Maybe a, Maybe b)

cunzipWith :: (Dom Maybe c, Dom Maybe a, Dom Maybe b) => (c -> (a, b)) -> Maybe c -> (Maybe a, Maybe b)

CUnzip Option

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Option (a, b), Dom Option a, Dom Option b) => Option (a, b) -> (Option a, Option b)

cunzipWith :: (Dom Option c, Dom Option a, Dom Option b) => (c -> (a, b)) -> Option c -> (Option a, Option b)

CUnzip ZipList

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom ZipList (a, b), Dom ZipList a, Dom ZipList b) => ZipList (a, b) -> (ZipList a, ZipList b)

cunzipWith :: (Dom ZipList c, Dom ZipList a, Dom ZipList b) => (c -> (a, b)) -> ZipList c -> (ZipList a, ZipList b)

CUnzip Identity

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Identity (a, b), Dom Identity a, Dom Identity b) => Identity (a, b) -> (Identity a, Identity b)

cunzipWith :: (Dom Identity c, Dom Identity a, Dom Identity b) => (c -> (a, b)) -> Identity c -> (Identity a, Identity b)

CUnzip NonEmpty

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom NonEmpty (a, b), Dom NonEmpty a, Dom NonEmpty b) => NonEmpty (a, b) -> (NonEmpty a, NonEmpty b)

cunzipWith :: (Dom NonEmpty c, Dom NonEmpty a, Dom NonEmpty b) => (c -> (a, b)) -> NonEmpty c -> (NonEmpty a, NonEmpty b)

CUnzip IntMap

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom IntMap (a, b), Dom IntMap a, Dom IntMap b) => IntMap (a, b) -> (IntMap a, IntMap b)

cunzipWith :: (Dom IntMap c, Dom IntMap a, Dom IntMap b) => (c -> (a, b)) -> IntMap c -> (IntMap a, IntMap b)

CUnzip Tree

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Tree (a, b), Dom Tree a, Dom Tree b) => Tree (a, b) -> (Tree a, Tree b)

cunzipWith :: (Dom Tree c, Dom Tree a, Dom Tree b) => (c -> (a, b)) -> Tree c -> (Tree a, Tree b)

CUnzip Seq

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Seq (a, b), Dom Seq a, Dom Seq b) => Seq (a, b) -> (Seq a, Seq b)

cunzipWith :: (Dom Seq c, Dom Seq a, Dom Seq b) => (c -> (a, b)) -> Seq c -> (Seq a, Seq b)

CUnzip Vector

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Vector (a, b), Dom Vector a, Dom Vector b) => Vector (a, b) -> (Vector a, Vector b)

cunzipWith :: (Dom Vector c, Dom Vector a, Dom Vector b) => (c -> (a, b)) -> Vector c -> (Vector a, Vector b)

CUnzip Vector

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Vector (a, b), Dom Vector a, Dom Vector b) => Vector (a, b) -> (Vector a, Vector b)

cunzipWith :: (Dom Vector c, Dom Vector a, Dom Vector b) => (c -> (a, b)) -> Vector c -> (Vector a, Vector b)

CUnzip Vector

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Vector (a, b), Dom Vector a, Dom Vector b) => Vector (a, b) -> (Vector a, Vector b)

cunzipWith :: (Dom Vector c, Dom Vector a, Dom Vector b) => (c -> (a, b)) -> Vector c -> (Vector a, Vector b)

CUnzip Vector

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Vector (a, b), Dom Vector a, Dom Vector b) => Vector (a, b) -> (Vector a, Vector b)

cunzipWith :: (Dom Vector c, Dom Vector a, Dom Vector b) => (c -> (a, b)) -> Vector c -> (Vector a, Vector b)

CUnzip (Proxy :: Type -> Type)

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom Proxy (a, b), Dom Proxy a, Dom Proxy b) => Proxy (a, b) -> (Proxy a, Proxy b)

cunzipWith :: (Dom Proxy c, Dom Proxy a, Dom Proxy b) => (c -> (a, b)) -> Proxy c -> (Proxy a, Proxy b)

Ord k => CUnzip (Map k)

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom (Map k) (a, b), Dom (Map k) a, Dom (Map k) b) => Map k (a, b) -> (Map k a, Map k b)

cunzipWith :: (Dom (Map k) c, Dom (Map k) a, Dom (Map k) b) => (c -> (a, b)) -> Map k c -> (Map k a, Map k b)

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

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom (HashMap k) (a, b), Dom (HashMap k) a, Dom (HashMap k) b) => HashMap k (a, b) -> (HashMap k a, HashMap k b)

cunzipWith :: (Dom (HashMap k) c, Dom (HashMap k) a, Dom (HashMap k) b) => (c -> (a, b)) -> HashMap k c -> (HashMap k a, HashMap k b)

Unzip f => CUnzip (WrapFunctor f)

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom (WrapFunctor f) (a, b), Dom (WrapFunctor f) a, Dom (WrapFunctor f) b) => WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)

cunzipWith :: (Dom (WrapFunctor f) c, Dom (WrapFunctor f) a, Dom (WrapFunctor f) b) => (c -> (a, b)) -> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)

(IsSequence mono, MonoZip mono) => CUnzip (WrapMono mono :: Type -> Type)

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom (WrapMono mono) (a, b), Dom (WrapMono mono) a, Dom (WrapMono mono) b) => WrapMono mono (a, b) -> (WrapMono mono a, WrapMono mono b)

cunzipWith :: (Dom (WrapMono mono) c, Dom (WrapMono mono) a, Dom (WrapMono mono) b) => (c -> (a, b)) -> WrapMono mono c -> (WrapMono mono a, WrapMono mono b)

(CUnzip f, CUnzip g) => CUnzip (f :*: g)

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom (f :*: g) (a, b), Dom (f :*: g) a, Dom (f :*: g) b) => (f :*: g) (a, b) -> ((f :*: g) a, (f :*: g) b)

cunzipWith :: (Dom (f :*: g) c, Dom (f :*: g) a, Dom (f :*: g) b) => (c -> (a, b)) -> (f :*: g) c -> ((f :*: g) a, (f :*: g) b)

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

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom (Product f g) (a, b), Dom (Product f g) a, Dom (Product f g) b) => Product f g (a, b) -> (Product f g a, Product f g b)

cunzipWith :: (Dom (Product f g) c, Dom (Product f g) a, Dom (Product f g) b) => (c -> (a, b)) -> Product f g c -> (Product f g a, Product f g b)

(CUnzip f, CUnzip g) => CUnzip (f :.: g)

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom (f :.: g) (a, b), Dom (f :.: g) a, Dom (f :.: g) b) => (f :.: g) (a, b) -> ((f :.: g) a, (f :.: g) b)

cunzipWith :: (Dom (f :.: g) c, Dom (f :.: g) a, Dom (f :.: g) b) => (c -> (a, b)) -> (f :.: g) c -> ((f :.: g) a, (f :.: g) b)

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

Defined in Control.Subcategory.Zip

Methods

cunzip :: (Dom (Compose f g) (a, b), Dom (Compose f g) a, Dom (Compose f g) b) => Compose f g (a, b) -> (Compose f g a, Compose f g b)

cunzipWith :: (Dom (Compose f g) c, Dom (Compose f g) a, Dom (Compose f g) b) => (c -> (a, b)) -> Compose f g c -> (Compose f g a, Compose f g b)

cunzipDefault :: (CFunctor f, Dom f (a, b), Dom f a, Dom f b) => f (a, b) -> (f a, f b)

newtype CZippy f a

Constructors

CZippy

Fields

• runCZippy :: f a

Instances

Functor f => Functor (CZippy f)

Defined in Control.Subcategory.Zip

Methods

fmap :: (a -> b) -> CZippy f a -> CZippy f b

(<$) :: a -> CZippy f b -> CZippy f a

Semialign f => Semialign (CZippy f)

Defined in Control.Subcategory.Zip

Methods

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

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

Zip f => Zip (CZippy f)

Defined in Control.Subcategory.Zip

Methods

zip :: CZippy f a -> CZippy f b -> CZippy f (a, b)

zipWith :: (a -> b -> c) -> CZippy f a -> CZippy f b -> CZippy f c

Repeat f => Repeat (CZippy f)

Defined in Control.Subcategory.Zip

Methods

repeat :: a -> CZippy f a

CFunctor f => CFunctor (CZippy f)

Defined in Control.Subcategory.Zip

Methods

cmap :: (Dom (CZippy f) a, Dom (CZippy f) b) => (a -> b) -> CZippy f a -> CZippy f b

(<$:) :: (Dom (CZippy f) a, Dom (CZippy f) b) => a -> CZippy f b -> CZippy f a

Constrained (CZippy f)

Defined in Control.Subcategory.Zip

Associated Types

type Dom (CZippy f) a :: Constraint

CSemialign f => CSemialign (CZippy f)

Defined in Control.Subcategory.Zip

Methods

calignWith :: (Dom (CZippy f) a, Dom (CZippy f) b, Dom (CZippy f) c) => (These a b -> c) -> CZippy f a -> CZippy f b -> CZippy f c

calign :: (Dom (CZippy f) a, Dom (CZippy f) b, Dom (CZippy f) (These a b)) => CZippy f a -> CZippy f b -> CZippy f (These a b)

CRepeat f => CRepeat (CZippy f)

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom (CZippy f) a => a -> CZippy f a

CZip f => CZip (CZippy f)

Defined in Control.Subcategory.Zip

Methods

czipWith :: (Dom (CZippy f) a, Dom (CZippy f) b, Dom (CZippy f) c) => (a -> b -> c) -> CZippy f a -> CZippy f b -> CZippy f c

czip :: (Dom (CZippy f) a, Dom (CZippy f) b, Dom (CZippy f) (a, b)) => CZippy f a -> CZippy f b -> CZippy f (a, b)

Eq (f a) => Eq (CZippy f a)

Defined in Control.Subcategory.Zip

Methods

(==) :: CZippy f a -> CZippy f a -> Bool

(/=) :: CZippy f a -> CZippy f a -> Bool

Ord (f a) => Ord (CZippy f a)

Defined in Control.Subcategory.Zip

Methods

compare :: CZippy f a -> CZippy f a -> Ordering

(<) :: CZippy f a -> CZippy f a -> Bool

(<=) :: CZippy f a -> CZippy f a -> Bool

(>) :: CZippy f a -> CZippy f a -> Bool

(>=) :: CZippy f a -> CZippy f a -> Bool

max :: CZippy f a -> CZippy f a -> CZippy f a

min :: CZippy f a -> CZippy f a -> CZippy f a

Read (f a) => Read (CZippy f a)

Defined in Control.Subcategory.Zip

Methods

readsPrec :: Int -> ReadS (CZippy f a)

readList :: ReadS [CZippy f a]

readPrec :: ReadPrec (CZippy f a)

readListPrec :: ReadPrec [CZippy f a]

Show (f a) => Show (CZippy f a)

Defined in Control.Subcategory.Zip

Methods

showsPrec :: Int -> CZippy f a -> ShowS

show :: CZippy f a -> String

showList :: [CZippy f a] -> ShowS

(CZip f, Dom f a, Semigroup a) => Semigroup (CZippy f a)

Defined in Control.Subcategory.Zip

Methods

(<>) :: CZippy f a -> CZippy f a -> CZippy f a

sconcat :: NonEmpty (CZippy f a) -> CZippy f a

stimes :: Integral b => b -> CZippy f a -> CZippy f a

(CRepeat f, Dom f a, Monoid a) => Monoid (CZippy f a)

Defined in Control.Subcategory.Zip

Methods

mempty :: CZippy f a

mappend :: CZippy f a -> CZippy f a -> CZippy f a

mconcat :: [CZippy f a] -> CZippy f a

type Dom (CZippy f) a

Defined in Control.Subcategory.Zip

type Dom (CZippy f) a = Dom f a

class CZip f => CRepeat f where

Methods

crepeat :: Dom f a => a -> f a

Instances

CRepeat []

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom [] a => a -> [a]

CRepeat Maybe

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom Maybe a => a -> Maybe a

CRepeat Option

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom Option a => a -> Option a

CRepeat ZipList

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom ZipList a => a -> ZipList a

CRepeat Identity

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom Identity a => a -> Identity a

CRepeat NonEmpty

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom NonEmpty a => a -> NonEmpty a

CRepeat Tree

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom Tree a => a -> Tree a

Repeat f => CRepeat (WrapFunctor f)

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom (WrapFunctor f) a => a -> WrapFunctor f a

CRepeat f => CRepeat (CZippy f)

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom (CZippy f) a => a -> CZippy f a

CRepeat ((->) e :: Type -> Type)

Defined in Control.Subcategory.Zip

Methods

crepeat :: Dom ((->) e) a => a -> e -> a

module Control.Subcategory.Semialign