Control.Subcategory.Foldable

Documentation

class Constrained f => CFoldable f where

Minimal complete definition

cfoldMap | cfoldr

Methods

cfoldMap :: (Dom f a, Monoid w) => (a -> w) -> f a -> w

cfoldMap' :: (Dom f a, Monoid m) => (a -> m) -> f a -> m

cfold :: (Dom f w, Monoid w) => f w -> w

cfoldr :: Dom f a => (a -> b -> b) -> b -> f a -> b

cfoldlM :: (Monad m, Dom f b) => (a -> b -> m a) -> a -> f b -> m a

cfoldlM' :: (Monad m, Dom f b) => (a -> b -> m a) -> a -> f b -> m a

cfoldrM :: (Monad m, Dom f a) => (a -> b -> m b) -> b -> f a -> m b

cfoldrM' :: (Monad m, Dom f a) => (a -> b -> m b) -> b -> f a -> m b

cfoldl :: Dom f a => (b -> a -> b) -> b -> f a -> b

cfoldr' :: Dom f a => (a -> b -> b) -> b -> f a -> b

cfoldl' :: Dom f a => (b -> a -> b) -> b -> f a -> b

cbasicToList :: Dom f a => f a -> [a]

cfoldr1 :: Dom f a => (a -> a -> a) -> f a -> a

cfoldl1 :: Dom f a => (a -> a -> a) -> f a -> a

cindex :: Dom f a => f a -> Int -> a

cnull :: Dom f a => f a -> Bool

clength :: Dom f a => f a -> Int

cany :: Dom f a => (a -> Bool) -> f a -> Bool

call :: Dom f a => (a -> Bool) -> f a -> Bool

celem :: (Eq a, Dom f a) => a -> f a -> Bool

cnotElem :: (Eq a, Dom f a) => a -> f a -> Bool

cminimum :: (Ord a, Dom f a) => f a -> a

cmaximum :: (Ord a, Dom f a) => f a -> a

csum :: (Num a, Dom f a) => f a -> a

cproduct :: (Num a, Dom f a) => f a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom f a, Dom g b) => (a -> g b) -> f a -> g ()

ctraverse_ :: (Applicative g, Dom f a) => (a -> g b) -> f a -> g ()

clast :: Dom f a => f a -> a

chead :: Dom f a => f a -> a

cfind :: Dom f a => (a -> Bool) -> f a -> Maybe a

cfindIndex :: Dom f a => (a -> Bool) -> f a -> Maybe Int

cfindIndices :: Dom f a => (a -> Bool) -> f a -> [Int]

celemIndex :: (Dom f a, Eq a) => a -> f a -> Maybe Int

celemIndices :: (Dom f a, Eq a) => a -> f a -> [Int]

Instances

CFoldable []

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom [] a, Monoid w) => (a -> w) -> [a] -> w

cfoldMap' :: (Dom [] a, Monoid m) => (a -> m) -> [a] -> m

cfold :: (Dom [] w, Monoid w) => [w] -> w

cfoldr :: Dom [] a => (a -> b -> b) -> b -> [a] -> b

cfoldlM :: (Monad m, Dom [] b) => (a -> b -> m a) -> a -> [b] -> m a

cfoldlM' :: (Monad m, Dom [] b) => (a -> b -> m a) -> a -> [b] -> m a

cfoldrM :: (Monad m, Dom [] a) => (a -> b -> m b) -> b -> [a] -> m b

cfoldrM' :: (Monad m, Dom [] a) => (a -> b -> m b) -> b -> [a] -> m b

cfoldl :: Dom [] a => (b -> a -> b) -> b -> [a] -> b

cfoldr' :: Dom [] a => (a -> b -> b) -> b -> [a] -> b

cfoldl' :: Dom [] a => (b -> a -> b) -> b -> [a] -> b

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

cfoldr1 :: Dom [] a => (a -> a -> a) -> [a] -> a

cfoldl1 :: Dom [] a => (a -> a -> a) -> [a] -> a

cindex :: Dom [] a => [a] -> Int -> a

cnull :: Dom [] a => [a] -> Bool

clength :: Dom [] a => [a] -> Int

cany :: Dom [] a => (a -> Bool) -> [a] -> Bool

call :: Dom [] a => (a -> Bool) -> [a] -> Bool

celem :: (Eq a, Dom [] a) => a -> [a] -> Bool

cnotElem :: (Eq a, Dom [] a) => a -> [a] -> Bool

cminimum :: (Ord a, Dom [] a) => [a] -> a

cmaximum :: (Ord a, Dom [] a) => [a] -> a

csum :: (Num a, Dom [] a) => [a] -> a

cproduct :: (Num a, Dom [] a) => [a] -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom [] a, Dom g b) => (a -> g b) -> [a] -> g ()

ctraverse_ :: (Applicative g, Dom [] a) => (a -> g b) -> [a] -> g ()

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

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

cfind :: Dom [] a => (a -> Bool) -> [a] -> Maybe a

cfindIndex :: Dom [] a => (a -> Bool) -> [a] -> Maybe Int

cfindIndices :: Dom [] a => (a -> Bool) -> [a] -> [Int]

celemIndex :: (Dom [] a, Eq a) => a -> [a] -> Maybe Int

celemIndices :: (Dom [] a, Eq a) => a -> [a] -> [Int]

CFoldable Maybe

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Maybe a, Monoid w) => (a -> w) -> Maybe a -> w

cfoldMap' :: (Dom Maybe a, Monoid m) => (a -> m) -> Maybe a -> m

cfold :: (Dom Maybe w, Monoid w) => Maybe w -> w

cfoldr :: Dom Maybe a => (a -> b -> b) -> b -> Maybe a -> b

cfoldlM :: (Monad m, Dom Maybe b) => (a -> b -> m a) -> a -> Maybe b -> m a

cfoldlM' :: (Monad m, Dom Maybe b) => (a -> b -> m a) -> a -> Maybe b -> m a

cfoldrM :: (Monad m, Dom Maybe a) => (a -> b -> m b) -> b -> Maybe a -> m b

cfoldrM' :: (Monad m, Dom Maybe a) => (a -> b -> m b) -> b -> Maybe a -> m b

cfoldl :: Dom Maybe a => (b -> a -> b) -> b -> Maybe a -> b

cfoldr' :: Dom Maybe a => (a -> b -> b) -> b -> Maybe a -> b

cfoldl' :: Dom Maybe a => (b -> a -> b) -> b -> Maybe a -> b

cbasicToList :: Dom Maybe a => Maybe a -> [a]

cfoldr1 :: Dom Maybe a => (a -> a -> a) -> Maybe a -> a

cfoldl1 :: Dom Maybe a => (a -> a -> a) -> Maybe a -> a

cindex :: Dom Maybe a => Maybe a -> Int -> a

cnull :: Dom Maybe a => Maybe a -> Bool

clength :: Dom Maybe a => Maybe a -> Int

cany :: Dom Maybe a => (a -> Bool) -> Maybe a -> Bool

call :: Dom Maybe a => (a -> Bool) -> Maybe a -> Bool

celem :: (Eq a, Dom Maybe a) => a -> Maybe a -> Bool

cnotElem :: (Eq a, Dom Maybe a) => a -> Maybe a -> Bool

cminimum :: (Ord a, Dom Maybe a) => Maybe a -> a

cmaximum :: (Ord a, Dom Maybe a) => Maybe a -> a

csum :: (Num a, Dom Maybe a) => Maybe a -> a

cproduct :: (Num a, Dom Maybe a) => Maybe a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Maybe a, Dom g b) => (a -> g b) -> Maybe a -> g ()

ctraverse_ :: (Applicative g, Dom Maybe a) => (a -> g b) -> Maybe a -> g ()

clast :: Dom Maybe a => Maybe a -> a

chead :: Dom Maybe a => Maybe a -> a

cfind :: Dom Maybe a => (a -> Bool) -> Maybe a -> Maybe a

cfindIndex :: Dom Maybe a => (a -> Bool) -> Maybe a -> Maybe Int

cfindIndices :: Dom Maybe a => (a -> Bool) -> Maybe a -> [Int]

celemIndex :: (Dom Maybe a, Eq a) => a -> Maybe a -> Maybe Int

celemIndices :: (Dom Maybe a, Eq a) => a -> Maybe a -> [Int]

CFoldable Par1

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Par1 a, Monoid w) => (a -> w) -> Par1 a -> w

cfoldMap' :: (Dom Par1 a, Monoid m) => (a -> m) -> Par1 a -> m

cfold :: (Dom Par1 w, Monoid w) => Par1 w -> w

cfoldr :: Dom Par1 a => (a -> b -> b) -> b -> Par1 a -> b

cfoldlM :: (Monad m, Dom Par1 b) => (a -> b -> m a) -> a -> Par1 b -> m a

cfoldlM' :: (Monad m, Dom Par1 b) => (a -> b -> m a) -> a -> Par1 b -> m a

cfoldrM :: (Monad m, Dom Par1 a) => (a -> b -> m b) -> b -> Par1 a -> m b

cfoldrM' :: (Monad m, Dom Par1 a) => (a -> b -> m b) -> b -> Par1 a -> m b

cfoldl :: Dom Par1 a => (b -> a -> b) -> b -> Par1 a -> b

cfoldr' :: Dom Par1 a => (a -> b -> b) -> b -> Par1 a -> b

cfoldl' :: Dom Par1 a => (b -> a -> b) -> b -> Par1 a -> b

cbasicToList :: Dom Par1 a => Par1 a -> [a]

cfoldr1 :: Dom Par1 a => (a -> a -> a) -> Par1 a -> a

cfoldl1 :: Dom Par1 a => (a -> a -> a) -> Par1 a -> a

cindex :: Dom Par1 a => Par1 a -> Int -> a

cnull :: Dom Par1 a => Par1 a -> Bool

clength :: Dom Par1 a => Par1 a -> Int

cany :: Dom Par1 a => (a -> Bool) -> Par1 a -> Bool

call :: Dom Par1 a => (a -> Bool) -> Par1 a -> Bool

celem :: (Eq a, Dom Par1 a) => a -> Par1 a -> Bool

cnotElem :: (Eq a, Dom Par1 a) => a -> Par1 a -> Bool

cminimum :: (Ord a, Dom Par1 a) => Par1 a -> a

cmaximum :: (Ord a, Dom Par1 a) => Par1 a -> a

csum :: (Num a, Dom Par1 a) => Par1 a -> a

cproduct :: (Num a, Dom Par1 a) => Par1 a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Par1 a, Dom g b) => (a -> g b) -> Par1 a -> g ()

ctraverse_ :: (Applicative g, Dom Par1 a) => (a -> g b) -> Par1 a -> g ()

clast :: Dom Par1 a => Par1 a -> a

chead :: Dom Par1 a => Par1 a -> a

cfind :: Dom Par1 a => (a -> Bool) -> Par1 a -> Maybe a

cfindIndex :: Dom Par1 a => (a -> Bool) -> Par1 a -> Maybe Int

cfindIndices :: Dom Par1 a => (a -> Bool) -> Par1 a -> [Int]

celemIndex :: (Dom Par1 a, Eq a) => a -> Par1 a -> Maybe Int

celemIndices :: (Dom Par1 a, Eq a) => a -> Par1 a -> [Int]

CFoldable Complex

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Complex a, Monoid w) => (a -> w) -> Complex a -> w

cfoldMap' :: (Dom Complex a, Monoid m) => (a -> m) -> Complex a -> m

cfold :: (Dom Complex w, Monoid w) => Complex w -> w

cfoldr :: Dom Complex a => (a -> b -> b) -> b -> Complex a -> b

cfoldlM :: (Monad m, Dom Complex b) => (a -> b -> m a) -> a -> Complex b -> m a

cfoldlM' :: (Monad m, Dom Complex b) => (a -> b -> m a) -> a -> Complex b -> m a

cfoldrM :: (Monad m, Dom Complex a) => (a -> b -> m b) -> b -> Complex a -> m b

cfoldrM' :: (Monad m, Dom Complex a) => (a -> b -> m b) -> b -> Complex a -> m b

cfoldl :: Dom Complex a => (b -> a -> b) -> b -> Complex a -> b

cfoldr' :: Dom Complex a => (a -> b -> b) -> b -> Complex a -> b

cfoldl' :: Dom Complex a => (b -> a -> b) -> b -> Complex a -> b

cbasicToList :: Dom Complex a => Complex a -> [a]

cfoldr1 :: Dom Complex a => (a -> a -> a) -> Complex a -> a

cfoldl1 :: Dom Complex a => (a -> a -> a) -> Complex a -> a

cindex :: Dom Complex a => Complex a -> Int -> a

cnull :: Dom Complex a => Complex a -> Bool

clength :: Dom Complex a => Complex a -> Int

cany :: Dom Complex a => (a -> Bool) -> Complex a -> Bool

call :: Dom Complex a => (a -> Bool) -> Complex a -> Bool

celem :: (Eq a, Dom Complex a) => a -> Complex a -> Bool

cnotElem :: (Eq a, Dom Complex a) => a -> Complex a -> Bool

cminimum :: (Ord a, Dom Complex a) => Complex a -> a

cmaximum :: (Ord a, Dom Complex a) => Complex a -> a

csum :: (Num a, Dom Complex a) => Complex a -> a

cproduct :: (Num a, Dom Complex a) => Complex a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Complex a, Dom g b) => (a -> g b) -> Complex a -> g ()

ctraverse_ :: (Applicative g, Dom Complex a) => (a -> g b) -> Complex a -> g ()

clast :: Dom Complex a => Complex a -> a

chead :: Dom Complex a => Complex a -> a

cfind :: Dom Complex a => (a -> Bool) -> Complex a -> Maybe a

cfindIndex :: Dom Complex a => (a -> Bool) -> Complex a -> Maybe Int

cfindIndices :: Dom Complex a => (a -> Bool) -> Complex a -> [Int]

celemIndex :: (Dom Complex a, Eq a) => a -> Complex a -> Maybe Int

celemIndices :: (Dom Complex a, Eq a) => a -> Complex a -> [Int]

CFoldable Min

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Min a, Monoid w) => (a -> w) -> Min a -> w

cfoldMap' :: (Dom Min a, Monoid m) => (a -> m) -> Min a -> m

cfold :: (Dom Min w, Monoid w) => Min w -> w

cfoldr :: Dom Min a => (a -> b -> b) -> b -> Min a -> b

cfoldlM :: (Monad m, Dom Min b) => (a -> b -> m a) -> a -> Min b -> m a

cfoldlM' :: (Monad m, Dom Min b) => (a -> b -> m a) -> a -> Min b -> m a

cfoldrM :: (Monad m, Dom Min a) => (a -> b -> m b) -> b -> Min a -> m b

cfoldrM' :: (Monad m, Dom Min a) => (a -> b -> m b) -> b -> Min a -> m b

cfoldl :: Dom Min a => (b -> a -> b) -> b -> Min a -> b

cfoldr' :: Dom Min a => (a -> b -> b) -> b -> Min a -> b

cfoldl' :: Dom Min a => (b -> a -> b) -> b -> Min a -> b

cbasicToList :: Dom Min a => Min a -> [a]

cfoldr1 :: Dom Min a => (a -> a -> a) -> Min a -> a

cfoldl1 :: Dom Min a => (a -> a -> a) -> Min a -> a

cindex :: Dom Min a => Min a -> Int -> a

cnull :: Dom Min a => Min a -> Bool

clength :: Dom Min a => Min a -> Int

cany :: Dom Min a => (a -> Bool) -> Min a -> Bool

call :: Dom Min a => (a -> Bool) -> Min a -> Bool

celem :: (Eq a, Dom Min a) => a -> Min a -> Bool

cnotElem :: (Eq a, Dom Min a) => a -> Min a -> Bool

cminimum :: (Ord a, Dom Min a) => Min a -> a

cmaximum :: (Ord a, Dom Min a) => Min a -> a

csum :: (Num a, Dom Min a) => Min a -> a

cproduct :: (Num a, Dom Min a) => Min a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Min a, Dom g b) => (a -> g b) -> Min a -> g ()

ctraverse_ :: (Applicative g, Dom Min a) => (a -> g b) -> Min a -> g ()

clast :: Dom Min a => Min a -> a

chead :: Dom Min a => Min a -> a

cfind :: Dom Min a => (a -> Bool) -> Min a -> Maybe a

cfindIndex :: Dom Min a => (a -> Bool) -> Min a -> Maybe Int

cfindIndices :: Dom Min a => (a -> Bool) -> Min a -> [Int]

celemIndex :: (Dom Min a, Eq a) => a -> Min a -> Maybe Int

celemIndices :: (Dom Min a, Eq a) => a -> Min a -> [Int]

CFoldable Max

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Max a, Monoid w) => (a -> w) -> Max a -> w

cfoldMap' :: (Dom Max a, Monoid m) => (a -> m) -> Max a -> m

cfold :: (Dom Max w, Monoid w) => Max w -> w

cfoldr :: Dom Max a => (a -> b -> b) -> b -> Max a -> b

cfoldlM :: (Monad m, Dom Max b) => (a -> b -> m a) -> a -> Max b -> m a

cfoldlM' :: (Monad m, Dom Max b) => (a -> b -> m a) -> a -> Max b -> m a

cfoldrM :: (Monad m, Dom Max a) => (a -> b -> m b) -> b -> Max a -> m b

cfoldrM' :: (Monad m, Dom Max a) => (a -> b -> m b) -> b -> Max a -> m b

cfoldl :: Dom Max a => (b -> a -> b) -> b -> Max a -> b

cfoldr' :: Dom Max a => (a -> b -> b) -> b -> Max a -> b

cfoldl' :: Dom Max a => (b -> a -> b) -> b -> Max a -> b

cbasicToList :: Dom Max a => Max a -> [a]

cfoldr1 :: Dom Max a => (a -> a -> a) -> Max a -> a

cfoldl1 :: Dom Max a => (a -> a -> a) -> Max a -> a

cindex :: Dom Max a => Max a -> Int -> a

cnull :: Dom Max a => Max a -> Bool

clength :: Dom Max a => Max a -> Int

cany :: Dom Max a => (a -> Bool) -> Max a -> Bool

call :: Dom Max a => (a -> Bool) -> Max a -> Bool

celem :: (Eq a, Dom Max a) => a -> Max a -> Bool

cnotElem :: (Eq a, Dom Max a) => a -> Max a -> Bool

cminimum :: (Ord a, Dom Max a) => Max a -> a

cmaximum :: (Ord a, Dom Max a) => Max a -> a

csum :: (Num a, Dom Max a) => Max a -> a

cproduct :: (Num a, Dom Max a) => Max a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Max a, Dom g b) => (a -> g b) -> Max a -> g ()

ctraverse_ :: (Applicative g, Dom Max a) => (a -> g b) -> Max a -> g ()

clast :: Dom Max a => Max a -> a

chead :: Dom Max a => Max a -> a

cfind :: Dom Max a => (a -> Bool) -> Max a -> Maybe a

cfindIndex :: Dom Max a => (a -> Bool) -> Max a -> Maybe Int

cfindIndices :: Dom Max a => (a -> Bool) -> Max a -> [Int]

celemIndex :: (Dom Max a, Eq a) => a -> Max a -> Maybe Int

celemIndices :: (Dom Max a, Eq a) => a -> Max a -> [Int]

CFoldable First

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom First a, Monoid w) => (a -> w) -> First a -> w

cfoldMap' :: (Dom First a, Monoid m) => (a -> m) -> First a -> m

cfold :: (Dom First w, Monoid w) => First w -> w

cfoldr :: Dom First a => (a -> b -> b) -> b -> First a -> b

cfoldlM :: (Monad m, Dom First b) => (a -> b -> m a) -> a -> First b -> m a

cfoldlM' :: (Monad m, Dom First b) => (a -> b -> m a) -> a -> First b -> m a

cfoldrM :: (Monad m, Dom First a) => (a -> b -> m b) -> b -> First a -> m b

cfoldrM' :: (Monad m, Dom First a) => (a -> b -> m b) -> b -> First a -> m b

cfoldl :: Dom First a => (b -> a -> b) -> b -> First a -> b

cfoldr' :: Dom First a => (a -> b -> b) -> b -> First a -> b

cfoldl' :: Dom First a => (b -> a -> b) -> b -> First a -> b

cbasicToList :: Dom First a => First a -> [a]

cfoldr1 :: Dom First a => (a -> a -> a) -> First a -> a

cfoldl1 :: Dom First a => (a -> a -> a) -> First a -> a

cindex :: Dom First a => First a -> Int -> a

cnull :: Dom First a => First a -> Bool

clength :: Dom First a => First a -> Int

cany :: Dom First a => (a -> Bool) -> First a -> Bool

call :: Dom First a => (a -> Bool) -> First a -> Bool

celem :: (Eq a, Dom First a) => a -> First a -> Bool

cnotElem :: (Eq a, Dom First a) => a -> First a -> Bool

cminimum :: (Ord a, Dom First a) => First a -> a

cmaximum :: (Ord a, Dom First a) => First a -> a

csum :: (Num a, Dom First a) => First a -> a

cproduct :: (Num a, Dom First a) => First a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom First a, Dom g b) => (a -> g b) -> First a -> g ()

ctraverse_ :: (Applicative g, Dom First a) => (a -> g b) -> First a -> g ()

clast :: Dom First a => First a -> a

chead :: Dom First a => First a -> a

cfind :: Dom First a => (a -> Bool) -> First a -> Maybe a

cfindIndex :: Dom First a => (a -> Bool) -> First a -> Maybe Int

cfindIndices :: Dom First a => (a -> Bool) -> First a -> [Int]

celemIndex :: (Dom First a, Eq a) => a -> First a -> Maybe Int

celemIndices :: (Dom First a, Eq a) => a -> First a -> [Int]

CFoldable Last

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Last a, Monoid w) => (a -> w) -> Last a -> w

cfoldMap' :: (Dom Last a, Monoid m) => (a -> m) -> Last a -> m

cfold :: (Dom Last w, Monoid w) => Last w -> w

cfoldr :: Dom Last a => (a -> b -> b) -> b -> Last a -> b

cfoldlM :: (Monad m, Dom Last b) => (a -> b -> m a) -> a -> Last b -> m a

cfoldlM' :: (Monad m, Dom Last b) => (a -> b -> m a) -> a -> Last b -> m a

cfoldrM :: (Monad m, Dom Last a) => (a -> b -> m b) -> b -> Last a -> m b

cfoldrM' :: (Monad m, Dom Last a) => (a -> b -> m b) -> b -> Last a -> m b

cfoldl :: Dom Last a => (b -> a -> b) -> b -> Last a -> b

cfoldr' :: Dom Last a => (a -> b -> b) -> b -> Last a -> b

cfoldl' :: Dom Last a => (b -> a -> b) -> b -> Last a -> b

cbasicToList :: Dom Last a => Last a -> [a]

cfoldr1 :: Dom Last a => (a -> a -> a) -> Last a -> a

cfoldl1 :: Dom Last a => (a -> a -> a) -> Last a -> a

cindex :: Dom Last a => Last a -> Int -> a

cnull :: Dom Last a => Last a -> Bool

clength :: Dom Last a => Last a -> Int

cany :: Dom Last a => (a -> Bool) -> Last a -> Bool

call :: Dom Last a => (a -> Bool) -> Last a -> Bool

celem :: (Eq a, Dom Last a) => a -> Last a -> Bool

cnotElem :: (Eq a, Dom Last a) => a -> Last a -> Bool

cminimum :: (Ord a, Dom Last a) => Last a -> a

cmaximum :: (Ord a, Dom Last a) => Last a -> a

csum :: (Num a, Dom Last a) => Last a -> a

cproduct :: (Num a, Dom Last a) => Last a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Last a, Dom g b) => (a -> g b) -> Last a -> g ()

ctraverse_ :: (Applicative g, Dom Last a) => (a -> g b) -> Last a -> g ()

clast :: Dom Last a => Last a -> a

chead :: Dom Last a => Last a -> a

cfind :: Dom Last a => (a -> Bool) -> Last a -> Maybe a

cfindIndex :: Dom Last a => (a -> Bool) -> Last a -> Maybe Int

cfindIndices :: Dom Last a => (a -> Bool) -> Last a -> [Int]

celemIndex :: (Dom Last a, Eq a) => a -> Last a -> Maybe Int

celemIndices :: (Dom Last a, Eq a) => a -> Last a -> [Int]

CFoldable Option

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Option a, Monoid w) => (a -> w) -> Option a -> w

cfoldMap' :: (Dom Option a, Monoid m) => (a -> m) -> Option a -> m

cfold :: (Dom Option w, Monoid w) => Option w -> w

cfoldr :: Dom Option a => (a -> b -> b) -> b -> Option a -> b

cfoldlM :: (Monad m, Dom Option b) => (a -> b -> m a) -> a -> Option b -> m a

cfoldlM' :: (Monad m, Dom Option b) => (a -> b -> m a) -> a -> Option b -> m a

cfoldrM :: (Monad m, Dom Option a) => (a -> b -> m b) -> b -> Option a -> m b

cfoldrM' :: (Monad m, Dom Option a) => (a -> b -> m b) -> b -> Option a -> m b

cfoldl :: Dom Option a => (b -> a -> b) -> b -> Option a -> b

cfoldr' :: Dom Option a => (a -> b -> b) -> b -> Option a -> b

cfoldl' :: Dom Option a => (b -> a -> b) -> b -> Option a -> b

cbasicToList :: Dom Option a => Option a -> [a]

cfoldr1 :: Dom Option a => (a -> a -> a) -> Option a -> a

cfoldl1 :: Dom Option a => (a -> a -> a) -> Option a -> a

cindex :: Dom Option a => Option a -> Int -> a

cnull :: Dom Option a => Option a -> Bool

clength :: Dom Option a => Option a -> Int

cany :: Dom Option a => (a -> Bool) -> Option a -> Bool

call :: Dom Option a => (a -> Bool) -> Option a -> Bool

celem :: (Eq a, Dom Option a) => a -> Option a -> Bool

cnotElem :: (Eq a, Dom Option a) => a -> Option a -> Bool

cminimum :: (Ord a, Dom Option a) => Option a -> a

cmaximum :: (Ord a, Dom Option a) => Option a -> a

csum :: (Num a, Dom Option a) => Option a -> a

cproduct :: (Num a, Dom Option a) => Option a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Option a, Dom g b) => (a -> g b) -> Option a -> g ()

ctraverse_ :: (Applicative g, Dom Option a) => (a -> g b) -> Option a -> g ()

clast :: Dom Option a => Option a -> a

chead :: Dom Option a => Option a -> a

cfind :: Dom Option a => (a -> Bool) -> Option a -> Maybe a

cfindIndex :: Dom Option a => (a -> Bool) -> Option a -> Maybe Int

cfindIndices :: Dom Option a => (a -> Bool) -> Option a -> [Int]

celemIndex :: (Dom Option a, Eq a) => a -> Option a -> Maybe Int

celemIndices :: (Dom Option a, Eq a) => a -> Option a -> [Int]

CFoldable ZipList

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom ZipList a, Monoid w) => (a -> w) -> ZipList a -> w

cfoldMap' :: (Dom ZipList a, Monoid m) => (a -> m) -> ZipList a -> m

cfold :: (Dom ZipList w, Monoid w) => ZipList w -> w

cfoldr :: Dom ZipList a => (a -> b -> b) -> b -> ZipList a -> b

cfoldlM :: (Monad m, Dom ZipList b) => (a -> b -> m a) -> a -> ZipList b -> m a

cfoldlM' :: (Monad m, Dom ZipList b) => (a -> b -> m a) -> a -> ZipList b -> m a

cfoldrM :: (Monad m, Dom ZipList a) => (a -> b -> m b) -> b -> ZipList a -> m b

cfoldrM' :: (Monad m, Dom ZipList a) => (a -> b -> m b) -> b -> ZipList a -> m b

cfoldl :: Dom ZipList a => (b -> a -> b) -> b -> ZipList a -> b

cfoldr' :: Dom ZipList a => (a -> b -> b) -> b -> ZipList a -> b

cfoldl' :: Dom ZipList a => (b -> a -> b) -> b -> ZipList a -> b

cbasicToList :: Dom ZipList a => ZipList a -> [a]

cfoldr1 :: Dom ZipList a => (a -> a -> a) -> ZipList a -> a

cfoldl1 :: Dom ZipList a => (a -> a -> a) -> ZipList a -> a

cindex :: Dom ZipList a => ZipList a -> Int -> a

cnull :: Dom ZipList a => ZipList a -> Bool

clength :: Dom ZipList a => ZipList a -> Int

cany :: Dom ZipList a => (a -> Bool) -> ZipList a -> Bool

call :: Dom ZipList a => (a -> Bool) -> ZipList a -> Bool

celem :: (Eq a, Dom ZipList a) => a -> ZipList a -> Bool

cnotElem :: (Eq a, Dom ZipList a) => a -> ZipList a -> Bool

cminimum :: (Ord a, Dom ZipList a) => ZipList a -> a

cmaximum :: (Ord a, Dom ZipList a) => ZipList a -> a

csum :: (Num a, Dom ZipList a) => ZipList a -> a

cproduct :: (Num a, Dom ZipList a) => ZipList a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom ZipList a, Dom g b) => (a -> g b) -> ZipList a -> g ()

ctraverse_ :: (Applicative g, Dom ZipList a) => (a -> g b) -> ZipList a -> g ()

clast :: Dom ZipList a => ZipList a -> a

chead :: Dom ZipList a => ZipList a -> a

cfind :: Dom ZipList a => (a -> Bool) -> ZipList a -> Maybe a

cfindIndex :: Dom ZipList a => (a -> Bool) -> ZipList a -> Maybe Int

cfindIndices :: Dom ZipList a => (a -> Bool) -> ZipList a -> [Int]

celemIndex :: (Dom ZipList a, Eq a) => a -> ZipList a -> Maybe Int

celemIndices :: (Dom ZipList a, Eq a) => a -> ZipList a -> [Int]

CFoldable Identity

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Identity a, Monoid w) => (a -> w) -> Identity a -> w

cfoldMap' :: (Dom Identity a, Monoid m) => (a -> m) -> Identity a -> m

cfold :: (Dom Identity w, Monoid w) => Identity w -> w

cfoldr :: Dom Identity a => (a -> b -> b) -> b -> Identity a -> b

cfoldlM :: (Monad m, Dom Identity b) => (a -> b -> m a) -> a -> Identity b -> m a

cfoldlM' :: (Monad m, Dom Identity b) => (a -> b -> m a) -> a -> Identity b -> m a

cfoldrM :: (Monad m, Dom Identity a) => (a -> b -> m b) -> b -> Identity a -> m b

cfoldrM' :: (Monad m, Dom Identity a) => (a -> b -> m b) -> b -> Identity a -> m b

cfoldl :: Dom Identity a => (b -> a -> b) -> b -> Identity a -> b

cfoldr' :: Dom Identity a => (a -> b -> b) -> b -> Identity a -> b

cfoldl' :: Dom Identity a => (b -> a -> b) -> b -> Identity a -> b

cbasicToList :: Dom Identity a => Identity a -> [a]

cfoldr1 :: Dom Identity a => (a -> a -> a) -> Identity a -> a

cfoldl1 :: Dom Identity a => (a -> a -> a) -> Identity a -> a

cindex :: Dom Identity a => Identity a -> Int -> a

cnull :: Dom Identity a => Identity a -> Bool

clength :: Dom Identity a => Identity a -> Int

cany :: Dom Identity a => (a -> Bool) -> Identity a -> Bool

call :: Dom Identity a => (a -> Bool) -> Identity a -> Bool

celem :: (Eq a, Dom Identity a) => a -> Identity a -> Bool

cnotElem :: (Eq a, Dom Identity a) => a -> Identity a -> Bool

cminimum :: (Ord a, Dom Identity a) => Identity a -> a

cmaximum :: (Ord a, Dom Identity a) => Identity a -> a

csum :: (Num a, Dom Identity a) => Identity a -> a

cproduct :: (Num a, Dom Identity a) => Identity a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Identity a, Dom g b) => (a -> g b) -> Identity a -> g ()

ctraverse_ :: (Applicative g, Dom Identity a) => (a -> g b) -> Identity a -> g ()

clast :: Dom Identity a => Identity a -> a

chead :: Dom Identity a => Identity a -> a

cfind :: Dom Identity a => (a -> Bool) -> Identity a -> Maybe a

cfindIndex :: Dom Identity a => (a -> Bool) -> Identity a -> Maybe Int

cfindIndices :: Dom Identity a => (a -> Bool) -> Identity a -> [Int]

celemIndex :: (Dom Identity a, Eq a) => a -> Identity a -> Maybe Int

celemIndices :: (Dom Identity a, Eq a) => a -> Identity a -> [Int]

CFoldable First

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom First a, Monoid w) => (a -> w) -> First a -> w

cfoldMap' :: (Dom First a, Monoid m) => (a -> m) -> First a -> m

cfold :: (Dom First w, Monoid w) => First w -> w

cfoldr :: Dom First a => (a -> b -> b) -> b -> First a -> b

cfoldlM :: (Monad m, Dom First b) => (a -> b -> m a) -> a -> First b -> m a

cfoldlM' :: (Monad m, Dom First b) => (a -> b -> m a) -> a -> First b -> m a

cfoldrM :: (Monad m, Dom First a) => (a -> b -> m b) -> b -> First a -> m b

cfoldrM' :: (Monad m, Dom First a) => (a -> b -> m b) -> b -> First a -> m b

cfoldl :: Dom First a => (b -> a -> b) -> b -> First a -> b

cfoldr' :: Dom First a => (a -> b -> b) -> b -> First a -> b

cfoldl' :: Dom First a => (b -> a -> b) -> b -> First a -> b

cbasicToList :: Dom First a => First a -> [a]

cfoldr1 :: Dom First a => (a -> a -> a) -> First a -> a

cfoldl1 :: Dom First a => (a -> a -> a) -> First a -> a

cindex :: Dom First a => First a -> Int -> a

cnull :: Dom First a => First a -> Bool

clength :: Dom First a => First a -> Int

cany :: Dom First a => (a -> Bool) -> First a -> Bool

call :: Dom First a => (a -> Bool) -> First a -> Bool

celem :: (Eq a, Dom First a) => a -> First a -> Bool

cnotElem :: (Eq a, Dom First a) => a -> First a -> Bool

cminimum :: (Ord a, Dom First a) => First a -> a

cmaximum :: (Ord a, Dom First a) => First a -> a

csum :: (Num a, Dom First a) => First a -> a

cproduct :: (Num a, Dom First a) => First a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom First a, Dom g b) => (a -> g b) -> First a -> g ()

ctraverse_ :: (Applicative g, Dom First a) => (a -> g b) -> First a -> g ()

clast :: Dom First a => First a -> a

chead :: Dom First a => First a -> a

cfind :: Dom First a => (a -> Bool) -> First a -> Maybe a

cfindIndex :: Dom First a => (a -> Bool) -> First a -> Maybe Int

cfindIndices :: Dom First a => (a -> Bool) -> First a -> [Int]

celemIndex :: (Dom First a, Eq a) => a -> First a -> Maybe Int

celemIndices :: (Dom First a, Eq a) => a -> First a -> [Int]

CFoldable Last

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Last a, Monoid w) => (a -> w) -> Last a -> w

cfoldMap' :: (Dom Last a, Monoid m) => (a -> m) -> Last a -> m

cfold :: (Dom Last w, Monoid w) => Last w -> w

cfoldr :: Dom Last a => (a -> b -> b) -> b -> Last a -> b

cfoldlM :: (Monad m, Dom Last b) => (a -> b -> m a) -> a -> Last b -> m a

cfoldlM' :: (Monad m, Dom Last b) => (a -> b -> m a) -> a -> Last b -> m a

cfoldrM :: (Monad m, Dom Last a) => (a -> b -> m b) -> b -> Last a -> m b

cfoldrM' :: (Monad m, Dom Last a) => (a -> b -> m b) -> b -> Last a -> m b

cfoldl :: Dom Last a => (b -> a -> b) -> b -> Last a -> b

cfoldr' :: Dom Last a => (a -> b -> b) -> b -> Last a -> b

cfoldl' :: Dom Last a => (b -> a -> b) -> b -> Last a -> b

cbasicToList :: Dom Last a => Last a -> [a]

cfoldr1 :: Dom Last a => (a -> a -> a) -> Last a -> a

cfoldl1 :: Dom Last a => (a -> a -> a) -> Last a -> a

cindex :: Dom Last a => Last a -> Int -> a

cnull :: Dom Last a => Last a -> Bool

clength :: Dom Last a => Last a -> Int

cany :: Dom Last a => (a -> Bool) -> Last a -> Bool

call :: Dom Last a => (a -> Bool) -> Last a -> Bool

celem :: (Eq a, Dom Last a) => a -> Last a -> Bool

cnotElem :: (Eq a, Dom Last a) => a -> Last a -> Bool

cminimum :: (Ord a, Dom Last a) => Last a -> a

cmaximum :: (Ord a, Dom Last a) => Last a -> a

csum :: (Num a, Dom Last a) => Last a -> a

cproduct :: (Num a, Dom Last a) => Last a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Last a, Dom g b) => (a -> g b) -> Last a -> g ()

ctraverse_ :: (Applicative g, Dom Last a) => (a -> g b) -> Last a -> g ()

clast :: Dom Last a => Last a -> a

chead :: Dom Last a => Last a -> a

cfind :: Dom Last a => (a -> Bool) -> Last a -> Maybe a

cfindIndex :: Dom Last a => (a -> Bool) -> Last a -> Maybe Int

cfindIndices :: Dom Last a => (a -> Bool) -> Last a -> [Int]

celemIndex :: (Dom Last a, Eq a) => a -> Last a -> Maybe Int

celemIndices :: (Dom Last a, Eq a) => a -> Last a -> [Int]

CFoldable Down

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Down a, Monoid w) => (a -> w) -> Down a -> w

cfoldMap' :: (Dom Down a, Monoid m) => (a -> m) -> Down a -> m

cfold :: (Dom Down w, Monoid w) => Down w -> w

cfoldr :: Dom Down a => (a -> b -> b) -> b -> Down a -> b

cfoldlM :: (Monad m, Dom Down b) => (a -> b -> m a) -> a -> Down b -> m a

cfoldlM' :: (Monad m, Dom Down b) => (a -> b -> m a) -> a -> Down b -> m a

cfoldrM :: (Monad m, Dom Down a) => (a -> b -> m b) -> b -> Down a -> m b

cfoldrM' :: (Monad m, Dom Down a) => (a -> b -> m b) -> b -> Down a -> m b

cfoldl :: Dom Down a => (b -> a -> b) -> b -> Down a -> b

cfoldr' :: Dom Down a => (a -> b -> b) -> b -> Down a -> b

cfoldl' :: Dom Down a => (b -> a -> b) -> b -> Down a -> b

cbasicToList :: Dom Down a => Down a -> [a]

cfoldr1 :: Dom Down a => (a -> a -> a) -> Down a -> a

cfoldl1 :: Dom Down a => (a -> a -> a) -> Down a -> a

cindex :: Dom Down a => Down a -> Int -> a

cnull :: Dom Down a => Down a -> Bool

clength :: Dom Down a => Down a -> Int

cany :: Dom Down a => (a -> Bool) -> Down a -> Bool

call :: Dom Down a => (a -> Bool) -> Down a -> Bool

celem :: (Eq a, Dom Down a) => a -> Down a -> Bool

cnotElem :: (Eq a, Dom Down a) => a -> Down a -> Bool

cminimum :: (Ord a, Dom Down a) => Down a -> a

cmaximum :: (Ord a, Dom Down a) => Down a -> a

csum :: (Num a, Dom Down a) => Down a -> a

cproduct :: (Num a, Dom Down a) => Down a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Down a, Dom g b) => (a -> g b) -> Down a -> g ()

ctraverse_ :: (Applicative g, Dom Down a) => (a -> g b) -> Down a -> g ()

clast :: Dom Down a => Down a -> a

chead :: Dom Down a => Down a -> a

cfind :: Dom Down a => (a -> Bool) -> Down a -> Maybe a

cfindIndex :: Dom Down a => (a -> Bool) -> Down a -> Maybe Int

cfindIndices :: Dom Down a => (a -> Bool) -> Down a -> [Int]

celemIndex :: (Dom Down a, Eq a) => a -> Down a -> Maybe Int

celemIndices :: (Dom Down a, Eq a) => a -> Down a -> [Int]

CFoldable NonEmpty

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom NonEmpty a, Monoid w) => (a -> w) -> NonEmpty a -> w

cfoldMap' :: (Dom NonEmpty a, Monoid m) => (a -> m) -> NonEmpty a -> m

cfold :: (Dom NonEmpty w, Monoid w) => NonEmpty w -> w

cfoldr :: Dom NonEmpty a => (a -> b -> b) -> b -> NonEmpty a -> b

cfoldlM :: (Monad m, Dom NonEmpty b) => (a -> b -> m a) -> a -> NonEmpty b -> m a

cfoldlM' :: (Monad m, Dom NonEmpty b) => (a -> b -> m a) -> a -> NonEmpty b -> m a

cfoldrM :: (Monad m, Dom NonEmpty a) => (a -> b -> m b) -> b -> NonEmpty a -> m b

cfoldrM' :: (Monad m, Dom NonEmpty a) => (a -> b -> m b) -> b -> NonEmpty a -> m b

cfoldl :: Dom NonEmpty a => (b -> a -> b) -> b -> NonEmpty a -> b

cfoldr' :: Dom NonEmpty a => (a -> b -> b) -> b -> NonEmpty a -> b

cfoldl' :: Dom NonEmpty a => (b -> a -> b) -> b -> NonEmpty a -> b

cbasicToList :: Dom NonEmpty a => NonEmpty a -> [a]

cfoldr1 :: Dom NonEmpty a => (a -> a -> a) -> NonEmpty a -> a

cfoldl1 :: Dom NonEmpty a => (a -> a -> a) -> NonEmpty a -> a

cindex :: Dom NonEmpty a => NonEmpty a -> Int -> a

cnull :: Dom NonEmpty a => NonEmpty a -> Bool

clength :: Dom NonEmpty a => NonEmpty a -> Int

cany :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> Bool

call :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> Bool

celem :: (Eq a, Dom NonEmpty a) => a -> NonEmpty a -> Bool

cnotElem :: (Eq a, Dom NonEmpty a) => a -> NonEmpty a -> Bool

cminimum :: (Ord a, Dom NonEmpty a) => NonEmpty a -> a

cmaximum :: (Ord a, Dom NonEmpty a) => NonEmpty a -> a

csum :: (Num a, Dom NonEmpty a) => NonEmpty a -> a

cproduct :: (Num a, Dom NonEmpty a) => NonEmpty a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom NonEmpty a, Dom g b) => (a -> g b) -> NonEmpty a -> g ()

ctraverse_ :: (Applicative g, Dom NonEmpty a) => (a -> g b) -> NonEmpty a -> g ()

clast :: Dom NonEmpty a => NonEmpty a -> a

chead :: Dom NonEmpty a => NonEmpty a -> a

cfind :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> Maybe a

cfindIndex :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> Maybe Int

cfindIndices :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> [Int]

celemIndex :: (Dom NonEmpty a, Eq a) => a -> NonEmpty a -> Maybe Int

celemIndices :: (Dom NonEmpty a, Eq a) => a -> NonEmpty a -> [Int]

CFoldable IntMap

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom IntMap a, Monoid w) => (a -> w) -> IntMap a -> w

cfoldMap' :: (Dom IntMap a, Monoid m) => (a -> m) -> IntMap a -> m

cfold :: (Dom IntMap w, Monoid w) => IntMap w -> w

cfoldr :: Dom IntMap a => (a -> b -> b) -> b -> IntMap a -> b

cfoldlM :: (Monad m, Dom IntMap b) => (a -> b -> m a) -> a -> IntMap b -> m a

cfoldlM' :: (Monad m, Dom IntMap b) => (a -> b -> m a) -> a -> IntMap b -> m a

cfoldrM :: (Monad m, Dom IntMap a) => (a -> b -> m b) -> b -> IntMap a -> m b

cfoldrM' :: (Monad m, Dom IntMap a) => (a -> b -> m b) -> b -> IntMap a -> m b

cfoldl :: Dom IntMap a => (b -> a -> b) -> b -> IntMap a -> b

cfoldr' :: Dom IntMap a => (a -> b -> b) -> b -> IntMap a -> b

cfoldl' :: Dom IntMap a => (b -> a -> b) -> b -> IntMap a -> b

cbasicToList :: Dom IntMap a => IntMap a -> [a]

cfoldr1 :: Dom IntMap a => (a -> a -> a) -> IntMap a -> a

cfoldl1 :: Dom IntMap a => (a -> a -> a) -> IntMap a -> a

cindex :: Dom IntMap a => IntMap a -> Int -> a

cnull :: Dom IntMap a => IntMap a -> Bool

clength :: Dom IntMap a => IntMap a -> Int

cany :: Dom IntMap a => (a -> Bool) -> IntMap a -> Bool

call :: Dom IntMap a => (a -> Bool) -> IntMap a -> Bool

celem :: (Eq a, Dom IntMap a) => a -> IntMap a -> Bool

cnotElem :: (Eq a, Dom IntMap a) => a -> IntMap a -> Bool

cminimum :: (Ord a, Dom IntMap a) => IntMap a -> a

cmaximum :: (Ord a, Dom IntMap a) => IntMap a -> a

csum :: (Num a, Dom IntMap a) => IntMap a -> a

cproduct :: (Num a, Dom IntMap a) => IntMap a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom IntMap a, Dom g b) => (a -> g b) -> IntMap a -> g ()

ctraverse_ :: (Applicative g, Dom IntMap a) => (a -> g b) -> IntMap a -> g ()

clast :: Dom IntMap a => IntMap a -> a

chead :: Dom IntMap a => IntMap a -> a

cfind :: Dom IntMap a => (a -> Bool) -> IntMap a -> Maybe a

cfindIndex :: Dom IntMap a => (a -> Bool) -> IntMap a -> Maybe Int

cfindIndices :: Dom IntMap a => (a -> Bool) -> IntMap a -> [Int]

celemIndex :: (Dom IntMap a, Eq a) => a -> IntMap a -> Maybe Int

celemIndices :: (Dom IntMap a, Eq a) => a -> IntMap a -> [Int]

CFoldable Seq

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Seq a, Monoid w) => (a -> w) -> Seq a -> w

cfoldMap' :: (Dom Seq a, Monoid m) => (a -> m) -> Seq a -> m

cfold :: (Dom Seq w, Monoid w) => Seq w -> w

cfoldr :: Dom Seq a => (a -> b -> b) -> b -> Seq a -> b

cfoldlM :: (Monad m, Dom Seq b) => (a -> b -> m a) -> a -> Seq b -> m a

cfoldlM' :: (Monad m, Dom Seq b) => (a -> b -> m a) -> a -> Seq b -> m a

cfoldrM :: (Monad m, Dom Seq a) => (a -> b -> m b) -> b -> Seq a -> m b

cfoldrM' :: (Monad m, Dom Seq a) => (a -> b -> m b) -> b -> Seq a -> m b

cfoldl :: Dom Seq a => (b -> a -> b) -> b -> Seq a -> b

cfoldr' :: Dom Seq a => (a -> b -> b) -> b -> Seq a -> b

cfoldl' :: Dom Seq a => (b -> a -> b) -> b -> Seq a -> b

cbasicToList :: Dom Seq a => Seq a -> [a]

cfoldr1 :: Dom Seq a => (a -> a -> a) -> Seq a -> a

cfoldl1 :: Dom Seq a => (a -> a -> a) -> Seq a -> a

cindex :: Dom Seq a => Seq a -> Int -> a

cnull :: Dom Seq a => Seq a -> Bool

clength :: Dom Seq a => Seq a -> Int

cany :: Dom Seq a => (a -> Bool) -> Seq a -> Bool

call :: Dom Seq a => (a -> Bool) -> Seq a -> Bool

celem :: (Eq a, Dom Seq a) => a -> Seq a -> Bool

cnotElem :: (Eq a, Dom Seq a) => a -> Seq a -> Bool

cminimum :: (Ord a, Dom Seq a) => Seq a -> a

cmaximum :: (Ord a, Dom Seq a) => Seq a -> a

csum :: (Num a, Dom Seq a) => Seq a -> a

cproduct :: (Num a, Dom Seq a) => Seq a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Seq a, Dom g b) => (a -> g b) -> Seq a -> g ()

ctraverse_ :: (Applicative g, Dom Seq a) => (a -> g b) -> Seq a -> g ()

clast :: Dom Seq a => Seq a -> a

chead :: Dom Seq a => Seq a -> a

cfind :: Dom Seq a => (a -> Bool) -> Seq a -> Maybe a

cfindIndex :: Dom Seq a => (a -> Bool) -> Seq a -> Maybe Int

cfindIndices :: Dom Seq a => (a -> Bool) -> Seq a -> [Int]

celemIndex :: (Dom Seq a, Eq a) => a -> Seq a -> Maybe Int

celemIndices :: (Dom Seq a, Eq a) => a -> Seq a -> [Int]

CFoldable Set

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Set a, Monoid w) => (a -> w) -> Set a -> w

cfoldMap' :: (Dom Set a, Monoid m) => (a -> m) -> Set a -> m

cfold :: (Dom Set w, Monoid w) => Set w -> w

cfoldr :: Dom Set a => (a -> b -> b) -> b -> Set a -> b

cfoldlM :: (Monad m, Dom Set b) => (a -> b -> m a) -> a -> Set b -> m a

cfoldlM' :: (Monad m, Dom Set b) => (a -> b -> m a) -> a -> Set b -> m a

cfoldrM :: (Monad m, Dom Set a) => (a -> b -> m b) -> b -> Set a -> m b

cfoldrM' :: (Monad m, Dom Set a) => (a -> b -> m b) -> b -> Set a -> m b

cfoldl :: Dom Set a => (b -> a -> b) -> b -> Set a -> b

cfoldr' :: Dom Set a => (a -> b -> b) -> b -> Set a -> b

cfoldl' :: Dom Set a => (b -> a -> b) -> b -> Set a -> b

cbasicToList :: Dom Set a => Set a -> [a]

cfoldr1 :: Dom Set a => (a -> a -> a) -> Set a -> a

cfoldl1 :: Dom Set a => (a -> a -> a) -> Set a -> a

cindex :: Dom Set a => Set a -> Int -> a

cnull :: Dom Set a => Set a -> Bool

clength :: Dom Set a => Set a -> Int

cany :: Dom Set a => (a -> Bool) -> Set a -> Bool

call :: Dom Set a => (a -> Bool) -> Set a -> Bool

celem :: (Eq a, Dom Set a) => a -> Set a -> Bool

cnotElem :: (Eq a, Dom Set a) => a -> Set a -> Bool

cminimum :: (Ord a, Dom Set a) => Set a -> a

cmaximum :: (Ord a, Dom Set a) => Set a -> a

csum :: (Num a, Dom Set a) => Set a -> a

cproduct :: (Num a, Dom Set a) => Set a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Set a, Dom g b) => (a -> g b) -> Set a -> g ()

ctraverse_ :: (Applicative g, Dom Set a) => (a -> g b) -> Set a -> g ()

clast :: Dom Set a => Set a -> a

chead :: Dom Set a => Set a -> a

cfind :: Dom Set a => (a -> Bool) -> Set a -> Maybe a

cfindIndex :: Dom Set a => (a -> Bool) -> Set a -> Maybe Int

cfindIndices :: Dom Set a => (a -> Bool) -> Set a -> [Int]

celemIndex :: (Dom Set a, Eq a) => a -> Set a -> Maybe Int

celemIndices :: (Dom Set a, Eq a) => a -> Set a -> [Int]

CFoldable PrimArray

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom PrimArray a, Monoid w) => (a -> w) -> PrimArray a -> w

cfoldMap' :: (Dom PrimArray a, Monoid m) => (a -> m) -> PrimArray a -> m

cfold :: (Dom PrimArray w, Monoid w) => PrimArray w -> w

cfoldr :: Dom PrimArray a => (a -> b -> b) -> b -> PrimArray a -> b

cfoldlM :: (Monad m, Dom PrimArray b) => (a -> b -> m a) -> a -> PrimArray b -> m a

cfoldlM' :: (Monad m, Dom PrimArray b) => (a -> b -> m a) -> a -> PrimArray b -> m a

cfoldrM :: (Monad m, Dom PrimArray a) => (a -> b -> m b) -> b -> PrimArray a -> m b

cfoldrM' :: (Monad m, Dom PrimArray a) => (a -> b -> m b) -> b -> PrimArray a -> m b

cfoldl :: Dom PrimArray a => (b -> a -> b) -> b -> PrimArray a -> b

cfoldr' :: Dom PrimArray a => (a -> b -> b) -> b -> PrimArray a -> b

cfoldl' :: Dom PrimArray a => (b -> a -> b) -> b -> PrimArray a -> b

cbasicToList :: Dom PrimArray a => PrimArray a -> [a]

cfoldr1 :: Dom PrimArray a => (a -> a -> a) -> PrimArray a -> a

cfoldl1 :: Dom PrimArray a => (a -> a -> a) -> PrimArray a -> a

cindex :: Dom PrimArray a => PrimArray a -> Int -> a

cnull :: Dom PrimArray a => PrimArray a -> Bool

clength :: Dom PrimArray a => PrimArray a -> Int

cany :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> Bool

call :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> Bool

celem :: (Eq a, Dom PrimArray a) => a -> PrimArray a -> Bool

cnotElem :: (Eq a, Dom PrimArray a) => a -> PrimArray a -> Bool

cminimum :: (Ord a, Dom PrimArray a) => PrimArray a -> a

cmaximum :: (Ord a, Dom PrimArray a) => PrimArray a -> a

csum :: (Num a, Dom PrimArray a) => PrimArray a -> a

cproduct :: (Num a, Dom PrimArray a) => PrimArray a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom PrimArray a, Dom g b) => (a -> g b) -> PrimArray a -> g ()

ctraverse_ :: (Applicative g, Dom PrimArray a) => (a -> g b) -> PrimArray a -> g ()

clast :: Dom PrimArray a => PrimArray a -> a

chead :: Dom PrimArray a => PrimArray a -> a

cfind :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> Maybe a

cfindIndex :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> Maybe Int

cfindIndices :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> [Int]

celemIndex :: (Dom PrimArray a, Eq a) => a -> PrimArray a -> Maybe Int

celemIndices :: (Dom PrimArray a, Eq a) => a -> PrimArray a -> [Int]

CFoldable SmallArray

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom SmallArray a, Monoid w) => (a -> w) -> SmallArray a -> w

cfoldMap' :: (Dom SmallArray a, Monoid m) => (a -> m) -> SmallArray a -> m

cfold :: (Dom SmallArray w, Monoid w) => SmallArray w -> w

cfoldr :: Dom SmallArray a => (a -> b -> b) -> b -> SmallArray a -> b

cfoldlM :: (Monad m, Dom SmallArray b) => (a -> b -> m a) -> a -> SmallArray b -> m a

cfoldlM' :: (Monad m, Dom SmallArray b) => (a -> b -> m a) -> a -> SmallArray b -> m a

cfoldrM :: (Monad m, Dom SmallArray a) => (a -> b -> m b) -> b -> SmallArray a -> m b

cfoldrM' :: (Monad m, Dom SmallArray a) => (a -> b -> m b) -> b -> SmallArray a -> m b

cfoldl :: Dom SmallArray a => (b -> a -> b) -> b -> SmallArray a -> b

cfoldr' :: Dom SmallArray a => (a -> b -> b) -> b -> SmallArray a -> b

cfoldl' :: Dom SmallArray a => (b -> a -> b) -> b -> SmallArray a -> b

cbasicToList :: Dom SmallArray a => SmallArray a -> [a]

cfoldr1 :: Dom SmallArray a => (a -> a -> a) -> SmallArray a -> a

cfoldl1 :: Dom SmallArray a => (a -> a -> a) -> SmallArray a -> a

cindex :: Dom SmallArray a => SmallArray a -> Int -> a

cnull :: Dom SmallArray a => SmallArray a -> Bool

clength :: Dom SmallArray a => SmallArray a -> Int

cany :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> Bool

call :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> Bool

celem :: (Eq a, Dom SmallArray a) => a -> SmallArray a -> Bool

cnotElem :: (Eq a, Dom SmallArray a) => a -> SmallArray a -> Bool

cminimum :: (Ord a, Dom SmallArray a) => SmallArray a -> a

cmaximum :: (Ord a, Dom SmallArray a) => SmallArray a -> a

csum :: (Num a, Dom SmallArray a) => SmallArray a -> a

cproduct :: (Num a, Dom SmallArray a) => SmallArray a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom SmallArray a, Dom g b) => (a -> g b) -> SmallArray a -> g ()

ctraverse_ :: (Applicative g, Dom SmallArray a) => (a -> g b) -> SmallArray a -> g ()

clast :: Dom SmallArray a => SmallArray a -> a

chead :: Dom SmallArray a => SmallArray a -> a

cfind :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> Maybe a

cfindIndex :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> Maybe Int

cfindIndices :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> [Int]

celemIndex :: (Dom SmallArray a, Eq a) => a -> SmallArray a -> Maybe Int

celemIndices :: (Dom SmallArray a, Eq a) => a -> SmallArray a -> [Int]

CFoldable Array

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Array a, Monoid w) => (a -> w) -> Array a -> w

cfoldMap' :: (Dom Array a, Monoid m) => (a -> m) -> Array a -> m

cfold :: (Dom Array w, Monoid w) => Array w -> w

cfoldr :: Dom Array a => (a -> b -> b) -> b -> Array a -> b

cfoldlM :: (Monad m, Dom Array b) => (a -> b -> m a) -> a -> Array b -> m a

cfoldlM' :: (Monad m, Dom Array b) => (a -> b -> m a) -> a -> Array b -> m a

cfoldrM :: (Monad m, Dom Array a) => (a -> b -> m b) -> b -> Array a -> m b

cfoldrM' :: (Monad m, Dom Array a) => (a -> b -> m b) -> b -> Array a -> m b

cfoldl :: Dom Array a => (b -> a -> b) -> b -> Array a -> b

cfoldr' :: Dom Array a => (a -> b -> b) -> b -> Array a -> b

cfoldl' :: Dom Array a => (b -> a -> b) -> b -> Array a -> b

cbasicToList :: Dom Array a => Array a -> [a]

cfoldr1 :: Dom Array a => (a -> a -> a) -> Array a -> a

cfoldl1 :: Dom Array a => (a -> a -> a) -> Array a -> a

cindex :: Dom Array a => Array a -> Int -> a

cnull :: Dom Array a => Array a -> Bool

clength :: Dom Array a => Array a -> Int

cany :: Dom Array a => (a -> Bool) -> Array a -> Bool

call :: Dom Array a => (a -> Bool) -> Array a -> Bool

celem :: (Eq a, Dom Array a) => a -> Array a -> Bool

cnotElem :: (Eq a, Dom Array a) => a -> Array a -> Bool

cminimum :: (Ord a, Dom Array a) => Array a -> a

cmaximum :: (Ord a, Dom Array a) => Array a -> a

csum :: (Num a, Dom Array a) => Array a -> a

cproduct :: (Num a, Dom Array a) => Array a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Array a, Dom g b) => (a -> g b) -> Array a -> g ()

ctraverse_ :: (Applicative g, Dom Array a) => (a -> g b) -> Array a -> g ()

clast :: Dom Array a => Array a -> a

chead :: Dom Array a => Array a -> a

cfind :: Dom Array a => (a -> Bool) -> Array a -> Maybe a

cfindIndex :: Dom Array a => (a -> Bool) -> Array a -> Maybe Int

cfindIndices :: Dom Array a => (a -> Bool) -> Array a -> [Int]

celemIndex :: (Dom Array a, Eq a) => a -> Array a -> Maybe Int

celemIndices :: (Dom Array a, Eq a) => a -> Array a -> [Int]

CFoldable HashSet

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom HashSet a, Monoid w) => (a -> w) -> HashSet a -> w

cfoldMap' :: (Dom HashSet a, Monoid m) => (a -> m) -> HashSet a -> m

cfold :: (Dom HashSet w, Monoid w) => HashSet w -> w

cfoldr :: Dom HashSet a => (a -> b -> b) -> b -> HashSet a -> b

cfoldlM :: (Monad m, Dom HashSet b) => (a -> b -> m a) -> a -> HashSet b -> m a

cfoldlM' :: (Monad m, Dom HashSet b) => (a -> b -> m a) -> a -> HashSet b -> m a

cfoldrM :: (Monad m, Dom HashSet a) => (a -> b -> m b) -> b -> HashSet a -> m b

cfoldrM' :: (Monad m, Dom HashSet a) => (a -> b -> m b) -> b -> HashSet a -> m b

cfoldl :: Dom HashSet a => (b -> a -> b) -> b -> HashSet a -> b

cfoldr' :: Dom HashSet a => (a -> b -> b) -> b -> HashSet a -> b

cfoldl' :: Dom HashSet a => (b -> a -> b) -> b -> HashSet a -> b

cbasicToList :: Dom HashSet a => HashSet a -> [a]

cfoldr1 :: Dom HashSet a => (a -> a -> a) -> HashSet a -> a

cfoldl1 :: Dom HashSet a => (a -> a -> a) -> HashSet a -> a

cindex :: Dom HashSet a => HashSet a -> Int -> a

cnull :: Dom HashSet a => HashSet a -> Bool

clength :: Dom HashSet a => HashSet a -> Int

cany :: Dom HashSet a => (a -> Bool) -> HashSet a -> Bool

call :: Dom HashSet a => (a -> Bool) -> HashSet a -> Bool

celem :: (Eq a, Dom HashSet a) => a -> HashSet a -> Bool

cnotElem :: (Eq a, Dom HashSet a) => a -> HashSet a -> Bool

cminimum :: (Ord a, Dom HashSet a) => HashSet a -> a

cmaximum :: (Ord a, Dom HashSet a) => HashSet a -> a

csum :: (Num a, Dom HashSet a) => HashSet a -> a

cproduct :: (Num a, Dom HashSet a) => HashSet a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom HashSet a, Dom g b) => (a -> g b) -> HashSet a -> g ()

ctraverse_ :: (Applicative g, Dom HashSet a) => (a -> g b) -> HashSet a -> g ()

clast :: Dom HashSet a => HashSet a -> a

chead :: Dom HashSet a => HashSet a -> a

cfind :: Dom HashSet a => (a -> Bool) -> HashSet a -> Maybe a

cfindIndex :: Dom HashSet a => (a -> Bool) -> HashSet a -> Maybe Int

cfindIndices :: Dom HashSet a => (a -> Bool) -> HashSet a -> [Int]

celemIndex :: (Dom HashSet a, Eq a) => a -> HashSet a -> Maybe Int

celemIndices :: (Dom HashSet a, Eq a) => a -> HashSet a -> [Int]

CFoldable Vector

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w

cfoldMap' :: (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m

cfold :: (Dom Vector w, Monoid w) => Vector w -> w

cfoldr :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b

cfoldlM :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a

cfoldlM' :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a

cfoldrM :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b

cfoldrM' :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b

cfoldl :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b

cfoldr' :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b

cfoldl' :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b

cbasicToList :: Dom Vector a => Vector a -> [a]

cfoldr1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a

cfoldl1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a

cindex :: Dom Vector a => Vector a -> Int -> a

cnull :: Dom Vector a => Vector a -> Bool

clength :: Dom Vector a => Vector a -> Int

cany :: Dom Vector a => (a -> Bool) -> Vector a -> Bool

call :: Dom Vector a => (a -> Bool) -> Vector a -> Bool

celem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool

cnotElem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool

cminimum :: (Ord a, Dom Vector a) => Vector a -> a

cmaximum :: (Ord a, Dom Vector a) => Vector a -> a

csum :: (Num a, Dom Vector a) => Vector a -> a

cproduct :: (Num a, Dom Vector a) => Vector a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Vector a, Dom g b) => (a -> g b) -> Vector a -> g ()

ctraverse_ :: (Applicative g, Dom Vector a) => (a -> g b) -> Vector a -> g ()

clast :: Dom Vector a => Vector a -> a

chead :: Dom Vector a => Vector a -> a

cfind :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe a

cfindIndex :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int

cfindIndices :: Dom Vector a => (a -> Bool) -> Vector a -> [Int]

celemIndex :: (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int

celemIndices :: (Dom Vector a, Eq a) => a -> Vector a -> [Int]

CFoldable Vector

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w

cfoldMap' :: (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m

cfold :: (Dom Vector w, Monoid w) => Vector w -> w

cfoldr :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b

cfoldlM :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a

cfoldlM' :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a

cfoldrM :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b

cfoldrM' :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b

cfoldl :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b

cfoldr' :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b

cfoldl' :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b

cbasicToList :: Dom Vector a => Vector a -> [a]

cfoldr1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a

cfoldl1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a

cindex :: Dom Vector a => Vector a -> Int -> a

cnull :: Dom Vector a => Vector a -> Bool

clength :: Dom Vector a => Vector a -> Int

cany :: Dom Vector a => (a -> Bool) -> Vector a -> Bool

call :: Dom Vector a => (a -> Bool) -> Vector a -> Bool

celem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool

cnotElem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool

cminimum :: (Ord a, Dom Vector a) => Vector a -> a

cmaximum :: (Ord a, Dom Vector a) => Vector a -> a

csum :: (Num a, Dom Vector a) => Vector a -> a

cproduct :: (Num a, Dom Vector a) => Vector a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Vector a, Dom g b) => (a -> g b) -> Vector a -> g ()

ctraverse_ :: (Applicative g, Dom Vector a) => (a -> g b) -> Vector a -> g ()

clast :: Dom Vector a => Vector a -> a

chead :: Dom Vector a => Vector a -> a

cfind :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe a

cfindIndex :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int

cfindIndices :: Dom Vector a => (a -> Bool) -> Vector a -> [Int]

celemIndex :: (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int

celemIndices :: (Dom Vector a, Eq a) => a -> Vector a -> [Int]

CFoldable Vector

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w

cfoldMap' :: (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m

cfold :: (Dom Vector w, Monoid w) => Vector w -> w

cfoldr :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b

cfoldlM :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a

cfoldlM' :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a

cfoldrM :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b

cfoldrM' :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b

cfoldl :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b

cfoldr' :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b

cfoldl' :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b

cbasicToList :: Dom Vector a => Vector a -> [a]

cfoldr1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a

cfoldl1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a

cindex :: Dom Vector a => Vector a -> Int -> a

cnull :: Dom Vector a => Vector a -> Bool

clength :: Dom Vector a => Vector a -> Int

cany :: Dom Vector a => (a -> Bool) -> Vector a -> Bool

call :: Dom Vector a => (a -> Bool) -> Vector a -> Bool

celem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool

cnotElem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool

cminimum :: (Ord a, Dom Vector a) => Vector a -> a

cmaximum :: (Ord a, Dom Vector a) => Vector a -> a

csum :: (Num a, Dom Vector a) => Vector a -> a

cproduct :: (Num a, Dom Vector a) => Vector a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Vector a, Dom g b) => (a -> g b) -> Vector a -> g ()

ctraverse_ :: (Applicative g, Dom Vector a) => (a -> g b) -> Vector a -> g ()

clast :: Dom Vector a => Vector a -> a

chead :: Dom Vector a => Vector a -> a

cfind :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe a

cfindIndex :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int

cfindIndices :: Dom Vector a => (a -> Bool) -> Vector a -> [Int]

celemIndex :: (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int

celemIndices :: (Dom Vector a, Eq a) => a -> Vector a -> [Int]

CFoldable Vector

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w

cfoldMap' :: (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m

cfold :: (Dom Vector w, Monoid w) => Vector w -> w

cfoldr :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b

cfoldlM :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a

cfoldlM' :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a

cfoldrM :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b

cfoldrM' :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b

cfoldl :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b

cfoldr' :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b

cfoldl' :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b

cbasicToList :: Dom Vector a => Vector a -> [a]

cfoldr1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a

cfoldl1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a

cindex :: Dom Vector a => Vector a -> Int -> a

cnull :: Dom Vector a => Vector a -> Bool

clength :: Dom Vector a => Vector a -> Int

cany :: Dom Vector a => (a -> Bool) -> Vector a -> Bool

call :: Dom Vector a => (a -> Bool) -> Vector a -> Bool

celem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool

cnotElem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool

cminimum :: (Ord a, Dom Vector a) => Vector a -> a

cmaximum :: (Ord a, Dom Vector a) => Vector a -> a

csum :: (Num a, Dom Vector a) => Vector a -> a

cproduct :: (Num a, Dom Vector a) => Vector a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Vector a, Dom g b) => (a -> g b) -> Vector a -> g ()

ctraverse_ :: (Applicative g, Dom Vector a) => (a -> g b) -> Vector a -> g ()

clast :: Dom Vector a => Vector a -> a

chead :: Dom Vector a => Vector a -> a

cfind :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe a

cfindIndex :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int

cfindIndices :: Dom Vector a => (a -> Bool) -> Vector a -> [Int]

celemIndex :: (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int

celemIndices :: (Dom Vector a, Eq a) => a -> Vector a -> [Int]

CFoldable (Either e)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Either e) a, Monoid w) => (a -> w) -> Either e a -> w

cfoldMap' :: (Dom (Either e) a, Monoid m) => (a -> m) -> Either e a -> m

cfold :: (Dom (Either e) w, Monoid w) => Either e w -> w

cfoldr :: Dom (Either e) a => (a -> b -> b) -> b -> Either e a -> b

cfoldlM :: (Monad m, Dom (Either e) b) => (a -> b -> m a) -> a -> Either e b -> m a

cfoldlM' :: (Monad m, Dom (Either e) b) => (a -> b -> m a) -> a -> Either e b -> m a

cfoldrM :: (Monad m, Dom (Either e) a) => (a -> b -> m b) -> b -> Either e a -> m b

cfoldrM' :: (Monad m, Dom (Either e) a) => (a -> b -> m b) -> b -> Either e a -> m b

cfoldl :: Dom (Either e) a => (b -> a -> b) -> b -> Either e a -> b

cfoldr' :: Dom (Either e) a => (a -> b -> b) -> b -> Either e a -> b

cfoldl' :: Dom (Either e) a => (b -> a -> b) -> b -> Either e a -> b

cbasicToList :: Dom (Either e) a => Either e a -> [a]

cfoldr1 :: Dom (Either e) a => (a -> a -> a) -> Either e a -> a

cfoldl1 :: Dom (Either e) a => (a -> a -> a) -> Either e a -> a

cindex :: Dom (Either e) a => Either e a -> Int -> a

cnull :: Dom (Either e) a => Either e a -> Bool

clength :: Dom (Either e) a => Either e a -> Int

cany :: Dom (Either e) a => (a -> Bool) -> Either e a -> Bool

call :: Dom (Either e) a => (a -> Bool) -> Either e a -> Bool

celem :: (Eq a, Dom (Either e) a) => a -> Either e a -> Bool

cnotElem :: (Eq a, Dom (Either e) a) => a -> Either e a -> Bool

cminimum :: (Ord a, Dom (Either e) a) => Either e a -> a

cmaximum :: (Ord a, Dom (Either e) a) => Either e a -> a

csum :: (Num a, Dom (Either e) a) => Either e a -> a

cproduct :: (Num a, Dom (Either e) a) => Either e a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Either e) a, Dom g b) => (a -> g b) -> Either e a -> g ()

ctraverse_ :: (Applicative g, Dom (Either e) a) => (a -> g b) -> Either e a -> g ()

clast :: Dom (Either e) a => Either e a -> a

chead :: Dom (Either e) a => Either e a -> a

cfind :: Dom (Either e) a => (a -> Bool) -> Either e a -> Maybe a

cfindIndex :: Dom (Either e) a => (a -> Bool) -> Either e a -> Maybe Int

cfindIndices :: Dom (Either e) a => (a -> Bool) -> Either e a -> [Int]

celemIndex :: (Dom (Either e) a, Eq a) => a -> Either e a -> Maybe Int

celemIndices :: (Dom (Either e) a, Eq a) => a -> Either e a -> [Int]

CFoldable (V1 :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom V1 a, Monoid w) => (a -> w) -> V1 a -> w

cfoldMap' :: (Dom V1 a, Monoid m) => (a -> m) -> V1 a -> m

cfold :: (Dom V1 w, Monoid w) => V1 w -> w

cfoldr :: Dom V1 a => (a -> b -> b) -> b -> V1 a -> b

cfoldlM :: (Monad m, Dom V1 b) => (a -> b -> m a) -> a -> V1 b -> m a

cfoldlM' :: (Monad m, Dom V1 b) => (a -> b -> m a) -> a -> V1 b -> m a

cfoldrM :: (Monad m, Dom V1 a) => (a -> b -> m b) -> b -> V1 a -> m b

cfoldrM' :: (Monad m, Dom V1 a) => (a -> b -> m b) -> b -> V1 a -> m b

cfoldl :: Dom V1 a => (b -> a -> b) -> b -> V1 a -> b

cfoldr' :: Dom V1 a => (a -> b -> b) -> b -> V1 a -> b

cfoldl' :: Dom V1 a => (b -> a -> b) -> b -> V1 a -> b

cbasicToList :: Dom V1 a => V1 a -> [a]

cfoldr1 :: Dom V1 a => (a -> a -> a) -> V1 a -> a

cfoldl1 :: Dom V1 a => (a -> a -> a) -> V1 a -> a

cindex :: Dom V1 a => V1 a -> Int -> a

cnull :: Dom V1 a => V1 a -> Bool

clength :: Dom V1 a => V1 a -> Int

cany :: Dom V1 a => (a -> Bool) -> V1 a -> Bool

call :: Dom V1 a => (a -> Bool) -> V1 a -> Bool

celem :: (Eq a, Dom V1 a) => a -> V1 a -> Bool

cnotElem :: (Eq a, Dom V1 a) => a -> V1 a -> Bool

cminimum :: (Ord a, Dom V1 a) => V1 a -> a

cmaximum :: (Ord a, Dom V1 a) => V1 a -> a

csum :: (Num a, Dom V1 a) => V1 a -> a

cproduct :: (Num a, Dom V1 a) => V1 a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom V1 a, Dom g b) => (a -> g b) -> V1 a -> g ()

ctraverse_ :: (Applicative g, Dom V1 a) => (a -> g b) -> V1 a -> g ()

clast :: Dom V1 a => V1 a -> a

chead :: Dom V1 a => V1 a -> a

cfind :: Dom V1 a => (a -> Bool) -> V1 a -> Maybe a

cfindIndex :: Dom V1 a => (a -> Bool) -> V1 a -> Maybe Int

cfindIndices :: Dom V1 a => (a -> Bool) -> V1 a -> [Int]

celemIndex :: (Dom V1 a, Eq a) => a -> V1 a -> Maybe Int

celemIndices :: (Dom V1 a, Eq a) => a -> V1 a -> [Int]

CFoldable (U1 :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom U1 a, Monoid w) => (a -> w) -> U1 a -> w

cfoldMap' :: (Dom U1 a, Monoid m) => (a -> m) -> U1 a -> m

cfold :: (Dom U1 w, Monoid w) => U1 w -> w

cfoldr :: Dom U1 a => (a -> b -> b) -> b -> U1 a -> b

cfoldlM :: (Monad m, Dom U1 b) => (a -> b -> m a) -> a -> U1 b -> m a

cfoldlM' :: (Monad m, Dom U1 b) => (a -> b -> m a) -> a -> U1 b -> m a

cfoldrM :: (Monad m, Dom U1 a) => (a -> b -> m b) -> b -> U1 a -> m b

cfoldrM' :: (Monad m, Dom U1 a) => (a -> b -> m b) -> b -> U1 a -> m b

cfoldl :: Dom U1 a => (b -> a -> b) -> b -> U1 a -> b

cfoldr' :: Dom U1 a => (a -> b -> b) -> b -> U1 a -> b

cfoldl' :: Dom U1 a => (b -> a -> b) -> b -> U1 a -> b

cbasicToList :: Dom U1 a => U1 a -> [a]

cfoldr1 :: Dom U1 a => (a -> a -> a) -> U1 a -> a

cfoldl1 :: Dom U1 a => (a -> a -> a) -> U1 a -> a

cindex :: Dom U1 a => U1 a -> Int -> a

cnull :: Dom U1 a => U1 a -> Bool

clength :: Dom U1 a => U1 a -> Int

cany :: Dom U1 a => (a -> Bool) -> U1 a -> Bool

call :: Dom U1 a => (a -> Bool) -> U1 a -> Bool

celem :: (Eq a, Dom U1 a) => a -> U1 a -> Bool

cnotElem :: (Eq a, Dom U1 a) => a -> U1 a -> Bool

cminimum :: (Ord a, Dom U1 a) => U1 a -> a

cmaximum :: (Ord a, Dom U1 a) => U1 a -> a

csum :: (Num a, Dom U1 a) => U1 a -> a

cproduct :: (Num a, Dom U1 a) => U1 a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom U1 a, Dom g b) => (a -> g b) -> U1 a -> g ()

ctraverse_ :: (Applicative g, Dom U1 a) => (a -> g b) -> U1 a -> g ()

clast :: Dom U1 a => U1 a -> a

chead :: Dom U1 a => U1 a -> a

cfind :: Dom U1 a => (a -> Bool) -> U1 a -> Maybe a

cfindIndex :: Dom U1 a => (a -> Bool) -> U1 a -> Maybe Int

cfindIndices :: Dom U1 a => (a -> Bool) -> U1 a -> [Int]

celemIndex :: (Dom U1 a, Eq a) => a -> U1 a -> Maybe Int

celemIndices :: (Dom U1 a, Eq a) => a -> U1 a -> [Int]

CFoldable ((,) a)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom ((,) a) a0, Monoid w) => (a0 -> w) -> (a, a0) -> w

cfoldMap' :: (Dom ((,) a) a0, Monoid m) => (a0 -> m) -> (a, a0) -> m

cfold :: (Dom ((,) a) w, Monoid w) => (a, w) -> w

cfoldr :: Dom ((,) a) a0 => (a0 -> b -> b) -> b -> (a, a0) -> b

cfoldlM :: (Monad m, Dom ((,) a) b) => (a0 -> b -> m a0) -> a0 -> (a, b) -> m a0

cfoldlM' :: (Monad m, Dom ((,) a) b) => (a0 -> b -> m a0) -> a0 -> (a, b) -> m a0

cfoldrM :: (Monad m, Dom ((,) a) a0) => (a0 -> b -> m b) -> b -> (a, a0) -> m b

cfoldrM' :: (Monad m, Dom ((,) a) a0) => (a0 -> b -> m b) -> b -> (a, a0) -> m b

cfoldl :: Dom ((,) a) a0 => (b -> a0 -> b) -> b -> (a, a0) -> b

cfoldr' :: Dom ((,) a) a0 => (a0 -> b -> b) -> b -> (a, a0) -> b

cfoldl' :: Dom ((,) a) a0 => (b -> a0 -> b) -> b -> (a, a0) -> b

cbasicToList :: Dom ((,) a) a0 => (a, a0) -> [a0]

cfoldr1 :: Dom ((,) a) a0 => (a0 -> a0 -> a0) -> (a, a0) -> a0

cfoldl1 :: Dom ((,) a) a0 => (a0 -> a0 -> a0) -> (a, a0) -> a0

cindex :: Dom ((,) a) a0 => (a, a0) -> Int -> a0

cnull :: Dom ((,) a) a0 => (a, a0) -> Bool

clength :: Dom ((,) a) a0 => (a, a0) -> Int

cany :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> Bool

call :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> Bool

celem :: (Eq a0, Dom ((,) a) a0) => a0 -> (a, a0) -> Bool

cnotElem :: (Eq a0, Dom ((,) a) a0) => a0 -> (a, a0) -> Bool

cminimum :: (Ord a0, Dom ((,) a) a0) => (a, a0) -> a0

cmaximum :: (Ord a0, Dom ((,) a) a0) => (a, a0) -> a0

csum :: (Num a0, Dom ((,) a) a0) => (a, a0) -> a0

cproduct :: (Num a0, Dom ((,) a) a0) => (a, a0) -> a0

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom ((,) a) a0, Dom g b) => (a0 -> g b) -> (a, a0) -> g ()

ctraverse_ :: (Applicative g, Dom ((,) a) a0) => (a0 -> g b) -> (a, a0) -> g ()

clast :: Dom ((,) a) a0 => (a, a0) -> a0

chead :: Dom ((,) a) a0 => (a, a0) -> a0

cfind :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> Maybe a0

cfindIndex :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> Maybe Int

cfindIndices :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> [Int]

celemIndex :: (Dom ((,) a) a0, Eq a0) => a0 -> (a, a0) -> Maybe Int

celemIndices :: (Dom ((,) a) a0, Eq a0) => a0 -> (a, a0) -> [Int]

CFoldable (Arg a)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Arg a) a0, Monoid w) => (a0 -> w) -> Arg a a0 -> w

cfoldMap' :: (Dom (Arg a) a0, Monoid m) => (a0 -> m) -> Arg a a0 -> m

cfold :: (Dom (Arg a) w, Monoid w) => Arg a w -> w

cfoldr :: Dom (Arg a) a0 => (a0 -> b -> b) -> b -> Arg a a0 -> b

cfoldlM :: (Monad m, Dom (Arg a) b) => (a0 -> b -> m a0) -> a0 -> Arg a b -> m a0

cfoldlM' :: (Monad m, Dom (Arg a) b) => (a0 -> b -> m a0) -> a0 -> Arg a b -> m a0

cfoldrM :: (Monad m, Dom (Arg a) a0) => (a0 -> b -> m b) -> b -> Arg a a0 -> m b

cfoldrM' :: (Monad m, Dom (Arg a) a0) => (a0 -> b -> m b) -> b -> Arg a a0 -> m b

cfoldl :: Dom (Arg a) a0 => (b -> a0 -> b) -> b -> Arg a a0 -> b

cfoldr' :: Dom (Arg a) a0 => (a0 -> b -> b) -> b -> Arg a a0 -> b

cfoldl' :: Dom (Arg a) a0 => (b -> a0 -> b) -> b -> Arg a a0 -> b

cbasicToList :: Dom (Arg a) a0 => Arg a a0 -> [a0]

cfoldr1 :: Dom (Arg a) a0 => (a0 -> a0 -> a0) -> Arg a a0 -> a0

cfoldl1 :: Dom (Arg a) a0 => (a0 -> a0 -> a0) -> Arg a a0 -> a0

cindex :: Dom (Arg a) a0 => Arg a a0 -> Int -> a0

cnull :: Dom (Arg a) a0 => Arg a a0 -> Bool

clength :: Dom (Arg a) a0 => Arg a a0 -> Int

cany :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> Bool

call :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> Bool

celem :: (Eq a0, Dom (Arg a) a0) => a0 -> Arg a a0 -> Bool

cnotElem :: (Eq a0, Dom (Arg a) a0) => a0 -> Arg a a0 -> Bool

cminimum :: (Ord a0, Dom (Arg a) a0) => Arg a a0 -> a0

cmaximum :: (Ord a0, Dom (Arg a) a0) => Arg a a0 -> a0

csum :: (Num a0, Dom (Arg a) a0) => Arg a a0 -> a0

cproduct :: (Num a0, Dom (Arg a) a0) => Arg a a0 -> a0

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Arg a) a0, Dom g b) => (a0 -> g b) -> Arg a a0 -> g ()

ctraverse_ :: (Applicative g, Dom (Arg a) a0) => (a0 -> g b) -> Arg a a0 -> g ()

clast :: Dom (Arg a) a0 => Arg a a0 -> a0

chead :: Dom (Arg a) a0 => Arg a a0 -> a0

cfind :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> Maybe a0

cfindIndex :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> Maybe Int

cfindIndices :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> [Int]

celemIndex :: (Dom (Arg a) a0, Eq a0) => a0 -> Arg a a0 -> Maybe Int

celemIndices :: (Dom (Arg a) a0, Eq a0) => a0 -> Arg a a0 -> [Int]

CFoldable (Proxy :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom Proxy a, Monoid w) => (a -> w) -> Proxy a -> w

cfoldMap' :: (Dom Proxy a, Monoid m) => (a -> m) -> Proxy a -> m

cfold :: (Dom Proxy w, Monoid w) => Proxy w -> w

cfoldr :: Dom Proxy a => (a -> b -> b) -> b -> Proxy a -> b

cfoldlM :: (Monad m, Dom Proxy b) => (a -> b -> m a) -> a -> Proxy b -> m a

cfoldlM' :: (Monad m, Dom Proxy b) => (a -> b -> m a) -> a -> Proxy b -> m a

cfoldrM :: (Monad m, Dom Proxy a) => (a -> b -> m b) -> b -> Proxy a -> m b

cfoldrM' :: (Monad m, Dom Proxy a) => (a -> b -> m b) -> b -> Proxy a -> m b

cfoldl :: Dom Proxy a => (b -> a -> b) -> b -> Proxy a -> b

cfoldr' :: Dom Proxy a => (a -> b -> b) -> b -> Proxy a -> b

cfoldl' :: Dom Proxy a => (b -> a -> b) -> b -> Proxy a -> b

cbasicToList :: Dom Proxy a => Proxy a -> [a]

cfoldr1 :: Dom Proxy a => (a -> a -> a) -> Proxy a -> a

cfoldl1 :: Dom Proxy a => (a -> a -> a) -> Proxy a -> a

cindex :: Dom Proxy a => Proxy a -> Int -> a

cnull :: Dom Proxy a => Proxy a -> Bool

clength :: Dom Proxy a => Proxy a -> Int

cany :: Dom Proxy a => (a -> Bool) -> Proxy a -> Bool

call :: Dom Proxy a => (a -> Bool) -> Proxy a -> Bool

celem :: (Eq a, Dom Proxy a) => a -> Proxy a -> Bool

cnotElem :: (Eq a, Dom Proxy a) => a -> Proxy a -> Bool

cminimum :: (Ord a, Dom Proxy a) => Proxy a -> a

cmaximum :: (Ord a, Dom Proxy a) => Proxy a -> a

csum :: (Num a, Dom Proxy a) => Proxy a -> a

cproduct :: (Num a, Dom Proxy a) => Proxy a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Proxy a, Dom g b) => (a -> g b) -> Proxy a -> g ()

ctraverse_ :: (Applicative g, Dom Proxy a) => (a -> g b) -> Proxy a -> g ()

clast :: Dom Proxy a => Proxy a -> a

chead :: Dom Proxy a => Proxy a -> a

cfind :: Dom Proxy a => (a -> Bool) -> Proxy a -> Maybe a

cfindIndex :: Dom Proxy a => (a -> Bool) -> Proxy a -> Maybe Int

cfindIndices :: Dom Proxy a => (a -> Bool) -> Proxy a -> [Int]

celemIndex :: (Dom Proxy a, Eq a) => a -> Proxy a -> Maybe Int

celemIndices :: (Dom Proxy a, Eq a) => a -> Proxy a -> [Int]

CFoldable (Map k)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Map k) a, Monoid w) => (a -> w) -> Map k a -> w

cfoldMap' :: (Dom (Map k) a, Monoid m) => (a -> m) -> Map k a -> m

cfold :: (Dom (Map k) w, Monoid w) => Map k w -> w

cfoldr :: Dom (Map k) a => (a -> b -> b) -> b -> Map k a -> b

cfoldlM :: (Monad m, Dom (Map k) b) => (a -> b -> m a) -> a -> Map k b -> m a

cfoldlM' :: (Monad m, Dom (Map k) b) => (a -> b -> m a) -> a -> Map k b -> m a

cfoldrM :: (Monad m, Dom (Map k) a) => (a -> b -> m b) -> b -> Map k a -> m b

cfoldrM' :: (Monad m, Dom (Map k) a) => (a -> b -> m b) -> b -> Map k a -> m b

cfoldl :: Dom (Map k) a => (b -> a -> b) -> b -> Map k a -> b

cfoldr' :: Dom (Map k) a => (a -> b -> b) -> b -> Map k a -> b

cfoldl' :: Dom (Map k) a => (b -> a -> b) -> b -> Map k a -> b

cbasicToList :: Dom (Map k) a => Map k a -> [a]

cfoldr1 :: Dom (Map k) a => (a -> a -> a) -> Map k a -> a

cfoldl1 :: Dom (Map k) a => (a -> a -> a) -> Map k a -> a

cindex :: Dom (Map k) a => Map k a -> Int -> a

cnull :: Dom (Map k) a => Map k a -> Bool

clength :: Dom (Map k) a => Map k a -> Int

cany :: Dom (Map k) a => (a -> Bool) -> Map k a -> Bool

call :: Dom (Map k) a => (a -> Bool) -> Map k a -> Bool

celem :: (Eq a, Dom (Map k) a) => a -> Map k a -> Bool

cnotElem :: (Eq a, Dom (Map k) a) => a -> Map k a -> Bool

cminimum :: (Ord a, Dom (Map k) a) => Map k a -> a

cmaximum :: (Ord a, Dom (Map k) a) => Map k a -> a

csum :: (Num a, Dom (Map k) a) => Map k a -> a

cproduct :: (Num a, Dom (Map k) a) => Map k a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Map k) a, Dom g b) => (a -> g b) -> Map k a -> g ()

ctraverse_ :: (Applicative g, Dom (Map k) a) => (a -> g b) -> Map k a -> g ()

clast :: Dom (Map k) a => Map k a -> a

chead :: Dom (Map k) a => Map k a -> a

cfind :: Dom (Map k) a => (a -> Bool) -> Map k a -> Maybe a

cfindIndex :: Dom (Map k) a => (a -> Bool) -> Map k a -> Maybe Int

cfindIndices :: Dom (Map k) a => (a -> Bool) -> Map k a -> [Int]

celemIndex :: (Dom (Map k) a, Eq a) => a -> Map k a -> Maybe Int

celemIndices :: (Dom (Map k) a, Eq a) => a -> Map k a -> [Int]

CFoldable (HashMap k)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (HashMap k) a, Monoid w) => (a -> w) -> HashMap k a -> w

cfoldMap' :: (Dom (HashMap k) a, Monoid m) => (a -> m) -> HashMap k a -> m

cfold :: (Dom (HashMap k) w, Monoid w) => HashMap k w -> w

cfoldr :: Dom (HashMap k) a => (a -> b -> b) -> b -> HashMap k a -> b

cfoldlM :: (Monad m, Dom (HashMap k) b) => (a -> b -> m a) -> a -> HashMap k b -> m a

cfoldlM' :: (Monad m, Dom (HashMap k) b) => (a -> b -> m a) -> a -> HashMap k b -> m a

cfoldrM :: (Monad m, Dom (HashMap k) a) => (a -> b -> m b) -> b -> HashMap k a -> m b

cfoldrM' :: (Monad m, Dom (HashMap k) a) => (a -> b -> m b) -> b -> HashMap k a -> m b

cfoldl :: Dom (HashMap k) a => (b -> a -> b) -> b -> HashMap k a -> b

cfoldr' :: Dom (HashMap k) a => (a -> b -> b) -> b -> HashMap k a -> b

cfoldl' :: Dom (HashMap k) a => (b -> a -> b) -> b -> HashMap k a -> b

cbasicToList :: Dom (HashMap k) a => HashMap k a -> [a]

cfoldr1 :: Dom (HashMap k) a => (a -> a -> a) -> HashMap k a -> a

cfoldl1 :: Dom (HashMap k) a => (a -> a -> a) -> HashMap k a -> a

cindex :: Dom (HashMap k) a => HashMap k a -> Int -> a

cnull :: Dom (HashMap k) a => HashMap k a -> Bool

clength :: Dom (HashMap k) a => HashMap k a -> Int

cany :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> Bool

call :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> Bool

celem :: (Eq a, Dom (HashMap k) a) => a -> HashMap k a -> Bool

cnotElem :: (Eq a, Dom (HashMap k) a) => a -> HashMap k a -> Bool

cminimum :: (Ord a, Dom (HashMap k) a) => HashMap k a -> a

cmaximum :: (Ord a, Dom (HashMap k) a) => HashMap k a -> a

csum :: (Num a, Dom (HashMap k) a) => HashMap k a -> a

cproduct :: (Num a, Dom (HashMap k) a) => HashMap k a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (HashMap k) a, Dom g b) => (a -> g b) -> HashMap k a -> g ()

ctraverse_ :: (Applicative g, Dom (HashMap k) a) => (a -> g b) -> HashMap k a -> g ()

clast :: Dom (HashMap k) a => HashMap k a -> a

chead :: Dom (HashMap k) a => HashMap k a -> a

cfind :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> Maybe a

cfindIndex :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> Maybe Int

cfindIndices :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> [Int]

celemIndex :: (Dom (HashMap k) a, Eq a) => a -> HashMap k a -> Maybe Int

celemIndices :: (Dom (HashMap k) a, Eq a) => a -> HashMap k a -> [Int]

Foldable f => CFoldable (WrapFunctor f)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (WrapFunctor f) a, Monoid w) => (a -> w) -> WrapFunctor f a -> w

cfoldMap' :: (Dom (WrapFunctor f) a, Monoid m) => (a -> m) -> WrapFunctor f a -> m

cfold :: (Dom (WrapFunctor f) w, Monoid w) => WrapFunctor f w -> w

cfoldr :: Dom (WrapFunctor f) a => (a -> b -> b) -> b -> WrapFunctor f a -> b

cfoldlM :: (Monad m, Dom (WrapFunctor f) b) => (a -> b -> m a) -> a -> WrapFunctor f b -> m a

cfoldlM' :: (Monad m, Dom (WrapFunctor f) b) => (a -> b -> m a) -> a -> WrapFunctor f b -> m a

cfoldrM :: (Monad m, Dom (WrapFunctor f) a) => (a -> b -> m b) -> b -> WrapFunctor f a -> m b

cfoldrM' :: (Monad m, Dom (WrapFunctor f) a) => (a -> b -> m b) -> b -> WrapFunctor f a -> m b

cfoldl :: Dom (WrapFunctor f) a => (b -> a -> b) -> b -> WrapFunctor f a -> b

cfoldr' :: Dom (WrapFunctor f) a => (a -> b -> b) -> b -> WrapFunctor f a -> b

cfoldl' :: Dom (WrapFunctor f) a => (b -> a -> b) -> b -> WrapFunctor f a -> b

cbasicToList :: Dom (WrapFunctor f) a => WrapFunctor f a -> [a]

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

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

cindex :: Dom (WrapFunctor f) a => WrapFunctor f a -> Int -> a

cnull :: Dom (WrapFunctor f) a => WrapFunctor f a -> Bool

clength :: Dom (WrapFunctor f) a => WrapFunctor f a -> Int

cany :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> Bool

call :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> Bool

celem :: (Eq a, Dom (WrapFunctor f) a) => a -> WrapFunctor f a -> Bool

cnotElem :: (Eq a, Dom (WrapFunctor f) a) => a -> WrapFunctor f a -> Bool

cminimum :: (Ord a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a

cmaximum :: (Ord a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a

csum :: (Num a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a

cproduct :: (Num a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (WrapFunctor f) a, Dom g b) => (a -> g b) -> WrapFunctor f a -> g ()

ctraverse_ :: (Applicative g, Dom (WrapFunctor f) a) => (a -> g b) -> WrapFunctor f a -> g ()

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

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

cfind :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> Maybe a

cfindIndex :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> Maybe Int

cfindIndices :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> [Int]

celemIndex :: (Dom (WrapFunctor f) a, Eq a) => a -> WrapFunctor f a -> Maybe Int

celemIndices :: (Dom (WrapFunctor f) a, Eq a) => a -> WrapFunctor f a -> [Int]

Foldable f => CFoldable (Rec1 f)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Rec1 f) a, Monoid w) => (a -> w) -> Rec1 f a -> w

cfoldMap' :: (Dom (Rec1 f) a, Monoid m) => (a -> m) -> Rec1 f a -> m

cfold :: (Dom (Rec1 f) w, Monoid w) => Rec1 f w -> w

cfoldr :: Dom (Rec1 f) a => (a -> b -> b) -> b -> Rec1 f a -> b

cfoldlM :: (Monad m, Dom (Rec1 f) b) => (a -> b -> m a) -> a -> Rec1 f b -> m a

cfoldlM' :: (Monad m, Dom (Rec1 f) b) => (a -> b -> m a) -> a -> Rec1 f b -> m a

cfoldrM :: (Monad m, Dom (Rec1 f) a) => (a -> b -> m b) -> b -> Rec1 f a -> m b

cfoldrM' :: (Monad m, Dom (Rec1 f) a) => (a -> b -> m b) -> b -> Rec1 f a -> m b

cfoldl :: Dom (Rec1 f) a => (b -> a -> b) -> b -> Rec1 f a -> b

cfoldr' :: Dom (Rec1 f) a => (a -> b -> b) -> b -> Rec1 f a -> b

cfoldl' :: Dom (Rec1 f) a => (b -> a -> b) -> b -> Rec1 f a -> b

cbasicToList :: Dom (Rec1 f) a => Rec1 f a -> [a]

cfoldr1 :: Dom (Rec1 f) a => (a -> a -> a) -> Rec1 f a -> a

cfoldl1 :: Dom (Rec1 f) a => (a -> a -> a) -> Rec1 f a -> a

cindex :: Dom (Rec1 f) a => Rec1 f a -> Int -> a

cnull :: Dom (Rec1 f) a => Rec1 f a -> Bool

clength :: Dom (Rec1 f) a => Rec1 f a -> Int

cany :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> Bool

call :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> Bool

celem :: (Eq a, Dom (Rec1 f) a) => a -> Rec1 f a -> Bool

cnotElem :: (Eq a, Dom (Rec1 f) a) => a -> Rec1 f a -> Bool

cminimum :: (Ord a, Dom (Rec1 f) a) => Rec1 f a -> a

cmaximum :: (Ord a, Dom (Rec1 f) a) => Rec1 f a -> a

csum :: (Num a, Dom (Rec1 f) a) => Rec1 f a -> a

cproduct :: (Num a, Dom (Rec1 f) a) => Rec1 f a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Rec1 f) a, Dom g b) => (a -> g b) -> Rec1 f a -> g ()

ctraverse_ :: (Applicative g, Dom (Rec1 f) a) => (a -> g b) -> Rec1 f a -> g ()

clast :: Dom (Rec1 f) a => Rec1 f a -> a

chead :: Dom (Rec1 f) a => Rec1 f a -> a

cfind :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> Maybe a

cfindIndex :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> Maybe Int

cfindIndices :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> [Int]

celemIndex :: (Dom (Rec1 f) a, Eq a) => a -> Rec1 f a -> Maybe Int

celemIndices :: (Dom (Rec1 f) a, Eq a) => a -> Rec1 f a -> [Int]

CFoldable (URec Char :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (URec Char) a, Monoid w) => (a -> w) -> URec Char a -> w

cfoldMap' :: (Dom (URec Char) a, Monoid m) => (a -> m) -> URec Char a -> m

cfold :: (Dom (URec Char) w, Monoid w) => URec Char w -> w

cfoldr :: Dom (URec Char) a => (a -> b -> b) -> b -> URec Char a -> b

cfoldlM :: (Monad m, Dom (URec Char) b) => (a -> b -> m a) -> a -> URec Char b -> m a

cfoldlM' :: (Monad m, Dom (URec Char) b) => (a -> b -> m a) -> a -> URec Char b -> m a

cfoldrM :: (Monad m, Dom (URec Char) a) => (a -> b -> m b) -> b -> URec Char a -> m b

cfoldrM' :: (Monad m, Dom (URec Char) a) => (a -> b -> m b) -> b -> URec Char a -> m b

cfoldl :: Dom (URec Char) a => (b -> a -> b) -> b -> URec Char a -> b

cfoldr' :: Dom (URec Char) a => (a -> b -> b) -> b -> URec Char a -> b

cfoldl' :: Dom (URec Char) a => (b -> a -> b) -> b -> URec Char a -> b

cbasicToList :: Dom (URec Char) a => URec Char a -> [a]

cfoldr1 :: Dom (URec Char) a => (a -> a -> a) -> URec Char a -> a

cfoldl1 :: Dom (URec Char) a => (a -> a -> a) -> URec Char a -> a

cindex :: Dom (URec Char) a => URec Char a -> Int -> a

cnull :: Dom (URec Char) a => URec Char a -> Bool

clength :: Dom (URec Char) a => URec Char a -> Int

cany :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> Bool

call :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> Bool

celem :: (Eq a, Dom (URec Char) a) => a -> URec Char a -> Bool

cnotElem :: (Eq a, Dom (URec Char) a) => a -> URec Char a -> Bool

cminimum :: (Ord a, Dom (URec Char) a) => URec Char a -> a

cmaximum :: (Ord a, Dom (URec Char) a) => URec Char a -> a

csum :: (Num a, Dom (URec Char) a) => URec Char a -> a

cproduct :: (Num a, Dom (URec Char) a) => URec Char a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Char) a, Dom g b) => (a -> g b) -> URec Char a -> g ()

ctraverse_ :: (Applicative g, Dom (URec Char) a) => (a -> g b) -> URec Char a -> g ()

clast :: Dom (URec Char) a => URec Char a -> a

chead :: Dom (URec Char) a => URec Char a -> a

cfind :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> Maybe a

cfindIndex :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> Maybe Int

cfindIndices :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> [Int]

celemIndex :: (Dom (URec Char) a, Eq a) => a -> URec Char a -> Maybe Int

celemIndices :: (Dom (URec Char) a, Eq a) => a -> URec Char a -> [Int]

CFoldable (URec Double :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (URec Double) a, Monoid w) => (a -> w) -> URec Double a -> w

cfoldMap' :: (Dom (URec Double) a, Monoid m) => (a -> m) -> URec Double a -> m

cfold :: (Dom (URec Double) w, Monoid w) => URec Double w -> w

cfoldr :: Dom (URec Double) a => (a -> b -> b) -> b -> URec Double a -> b

cfoldlM :: (Monad m, Dom (URec Double) b) => (a -> b -> m a) -> a -> URec Double b -> m a

cfoldlM' :: (Monad m, Dom (URec Double) b) => (a -> b -> m a) -> a -> URec Double b -> m a

cfoldrM :: (Monad m, Dom (URec Double) a) => (a -> b -> m b) -> b -> URec Double a -> m b

cfoldrM' :: (Monad m, Dom (URec Double) a) => (a -> b -> m b) -> b -> URec Double a -> m b

cfoldl :: Dom (URec Double) a => (b -> a -> b) -> b -> URec Double a -> b

cfoldr' :: Dom (URec Double) a => (a -> b -> b) -> b -> URec Double a -> b

cfoldl' :: Dom (URec Double) a => (b -> a -> b) -> b -> URec Double a -> b

cbasicToList :: Dom (URec Double) a => URec Double a -> [a]

cfoldr1 :: Dom (URec Double) a => (a -> a -> a) -> URec Double a -> a

cfoldl1 :: Dom (URec Double) a => (a -> a -> a) -> URec Double a -> a

cindex :: Dom (URec Double) a => URec Double a -> Int -> a

cnull :: Dom (URec Double) a => URec Double a -> Bool

clength :: Dom (URec Double) a => URec Double a -> Int

cany :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> Bool

call :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> Bool

celem :: (Eq a, Dom (URec Double) a) => a -> URec Double a -> Bool

cnotElem :: (Eq a, Dom (URec Double) a) => a -> URec Double a -> Bool

cminimum :: (Ord a, Dom (URec Double) a) => URec Double a -> a

cmaximum :: (Ord a, Dom (URec Double) a) => URec Double a -> a

csum :: (Num a, Dom (URec Double) a) => URec Double a -> a

cproduct :: (Num a, Dom (URec Double) a) => URec Double a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Double) a, Dom g b) => (a -> g b) -> URec Double a -> g ()

ctraverse_ :: (Applicative g, Dom (URec Double) a) => (a -> g b) -> URec Double a -> g ()

clast :: Dom (URec Double) a => URec Double a -> a

chead :: Dom (URec Double) a => URec Double a -> a

cfind :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> Maybe a

cfindIndex :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> Maybe Int

cfindIndices :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> [Int]

celemIndex :: (Dom (URec Double) a, Eq a) => a -> URec Double a -> Maybe Int

celemIndices :: (Dom (URec Double) a, Eq a) => a -> URec Double a -> [Int]

CFoldable (URec Float :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (URec Float) a, Monoid w) => (a -> w) -> URec Float a -> w

cfoldMap' :: (Dom (URec Float) a, Monoid m) => (a -> m) -> URec Float a -> m

cfold :: (Dom (URec Float) w, Monoid w) => URec Float w -> w

cfoldr :: Dom (URec Float) a => (a -> b -> b) -> b -> URec Float a -> b

cfoldlM :: (Monad m, Dom (URec Float) b) => (a -> b -> m a) -> a -> URec Float b -> m a

cfoldlM' :: (Monad m, Dom (URec Float) b) => (a -> b -> m a) -> a -> URec Float b -> m a

cfoldrM :: (Monad m, Dom (URec Float) a) => (a -> b -> m b) -> b -> URec Float a -> m b

cfoldrM' :: (Monad m, Dom (URec Float) a) => (a -> b -> m b) -> b -> URec Float a -> m b

cfoldl :: Dom (URec Float) a => (b -> a -> b) -> b -> URec Float a -> b

cfoldr' :: Dom (URec Float) a => (a -> b -> b) -> b -> URec Float a -> b

cfoldl' :: Dom (URec Float) a => (b -> a -> b) -> b -> URec Float a -> b

cbasicToList :: Dom (URec Float) a => URec Float a -> [a]

cfoldr1 :: Dom (URec Float) a => (a -> a -> a) -> URec Float a -> a

cfoldl1 :: Dom (URec Float) a => (a -> a -> a) -> URec Float a -> a

cindex :: Dom (URec Float) a => URec Float a -> Int -> a

cnull :: Dom (URec Float) a => URec Float a -> Bool

clength :: Dom (URec Float) a => URec Float a -> Int

cany :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> Bool

call :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> Bool

celem :: (Eq a, Dom (URec Float) a) => a -> URec Float a -> Bool

cnotElem :: (Eq a, Dom (URec Float) a) => a -> URec Float a -> Bool

cminimum :: (Ord a, Dom (URec Float) a) => URec Float a -> a

cmaximum :: (Ord a, Dom (URec Float) a) => URec Float a -> a

csum :: (Num a, Dom (URec Float) a) => URec Float a -> a

cproduct :: (Num a, Dom (URec Float) a) => URec Float a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Float) a, Dom g b) => (a -> g b) -> URec Float a -> g ()

ctraverse_ :: (Applicative g, Dom (URec Float) a) => (a -> g b) -> URec Float a -> g ()

clast :: Dom (URec Float) a => URec Float a -> a

chead :: Dom (URec Float) a => URec Float a -> a

cfind :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> Maybe a

cfindIndex :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> Maybe Int

cfindIndices :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> [Int]

celemIndex :: (Dom (URec Float) a, Eq a) => a -> URec Float a -> Maybe Int

celemIndices :: (Dom (URec Float) a, Eq a) => a -> URec Float a -> [Int]

CFoldable (URec Int :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (URec Int) a, Monoid w) => (a -> w) -> URec Int a -> w

cfoldMap' :: (Dom (URec Int) a, Monoid m) => (a -> m) -> URec Int a -> m

cfold :: (Dom (URec Int) w, Monoid w) => URec Int w -> w

cfoldr :: Dom (URec Int) a => (a -> b -> b) -> b -> URec Int a -> b

cfoldlM :: (Monad m, Dom (URec Int) b) => (a -> b -> m a) -> a -> URec Int b -> m a

cfoldlM' :: (Monad m, Dom (URec Int) b) => (a -> b -> m a) -> a -> URec Int b -> m a

cfoldrM :: (Monad m, Dom (URec Int) a) => (a -> b -> m b) -> b -> URec Int a -> m b

cfoldrM' :: (Monad m, Dom (URec Int) a) => (a -> b -> m b) -> b -> URec Int a -> m b

cfoldl :: Dom (URec Int) a => (b -> a -> b) -> b -> URec Int a -> b

cfoldr' :: Dom (URec Int) a => (a -> b -> b) -> b -> URec Int a -> b

cfoldl' :: Dom (URec Int) a => (b -> a -> b) -> b -> URec Int a -> b

cbasicToList :: Dom (URec Int) a => URec Int a -> [a]

cfoldr1 :: Dom (URec Int) a => (a -> a -> a) -> URec Int a -> a

cfoldl1 :: Dom (URec Int) a => (a -> a -> a) -> URec Int a -> a

cindex :: Dom (URec Int) a => URec Int a -> Int -> a

cnull :: Dom (URec Int) a => URec Int a -> Bool

clength :: Dom (URec Int) a => URec Int a -> Int

cany :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> Bool

call :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> Bool

celem :: (Eq a, Dom (URec Int) a) => a -> URec Int a -> Bool

cnotElem :: (Eq a, Dom (URec Int) a) => a -> URec Int a -> Bool

cminimum :: (Ord a, Dom (URec Int) a) => URec Int a -> a

cmaximum :: (Ord a, Dom (URec Int) a) => URec Int a -> a

csum :: (Num a, Dom (URec Int) a) => URec Int a -> a

cproduct :: (Num a, Dom (URec Int) a) => URec Int a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Int) a, Dom g b) => (a -> g b) -> URec Int a -> g ()

ctraverse_ :: (Applicative g, Dom (URec Int) a) => (a -> g b) -> URec Int a -> g ()

clast :: Dom (URec Int) a => URec Int a -> a

chead :: Dom (URec Int) a => URec Int a -> a

cfind :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> Maybe a

cfindIndex :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> Maybe Int

cfindIndices :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> [Int]

celemIndex :: (Dom (URec Int) a, Eq a) => a -> URec Int a -> Maybe Int

celemIndices :: (Dom (URec Int) a, Eq a) => a -> URec Int a -> [Int]

CFoldable (URec Word :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (URec Word) a, Monoid w) => (a -> w) -> URec Word a -> w

cfoldMap' :: (Dom (URec Word) a, Monoid m) => (a -> m) -> URec Word a -> m

cfold :: (Dom (URec Word) w, Monoid w) => URec Word w -> w

cfoldr :: Dom (URec Word) a => (a -> b -> b) -> b -> URec Word a -> b

cfoldlM :: (Monad m, Dom (URec Word) b) => (a -> b -> m a) -> a -> URec Word b -> m a

cfoldlM' :: (Monad m, Dom (URec Word) b) => (a -> b -> m a) -> a -> URec Word b -> m a

cfoldrM :: (Monad m, Dom (URec Word) a) => (a -> b -> m b) -> b -> URec Word a -> m b

cfoldrM' :: (Monad m, Dom (URec Word) a) => (a -> b -> m b) -> b -> URec Word a -> m b

cfoldl :: Dom (URec Word) a => (b -> a -> b) -> b -> URec Word a -> b

cfoldr' :: Dom (URec Word) a => (a -> b -> b) -> b -> URec Word a -> b

cfoldl' :: Dom (URec Word) a => (b -> a -> b) -> b -> URec Word a -> b

cbasicToList :: Dom (URec Word) a => URec Word a -> [a]

cfoldr1 :: Dom (URec Word) a => (a -> a -> a) -> URec Word a -> a

cfoldl1 :: Dom (URec Word) a => (a -> a -> a) -> URec Word a -> a

cindex :: Dom (URec Word) a => URec Word a -> Int -> a

cnull :: Dom (URec Word) a => URec Word a -> Bool

clength :: Dom (URec Word) a => URec Word a -> Int

cany :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> Bool

call :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> Bool

celem :: (Eq a, Dom (URec Word) a) => a -> URec Word a -> Bool

cnotElem :: (Eq a, Dom (URec Word) a) => a -> URec Word a -> Bool

cminimum :: (Ord a, Dom (URec Word) a) => URec Word a -> a

cmaximum :: (Ord a, Dom (URec Word) a) => URec Word a -> a

csum :: (Num a, Dom (URec Word) a) => URec Word a -> a

cproduct :: (Num a, Dom (URec Word) a) => URec Word a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Word) a, Dom g b) => (a -> g b) -> URec Word a -> g ()

ctraverse_ :: (Applicative g, Dom (URec Word) a) => (a -> g b) -> URec Word a -> g ()

clast :: Dom (URec Word) a => URec Word a -> a

chead :: Dom (URec Word) a => URec Word a -> a

cfind :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> Maybe a

cfindIndex :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> Maybe Int

cfindIndices :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> [Int]

celemIndex :: (Dom (URec Word) a, Eq a) => a -> URec Word a -> Maybe Int

celemIndices :: (Dom (URec Word) a, Eq a) => a -> URec Word a -> [Int]

CFoldable (URec (Ptr ()) :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (URec (Ptr ())) a, Monoid w) => (a -> w) -> URec (Ptr ()) a -> w

cfoldMap' :: (Dom (URec (Ptr ())) a, Monoid m) => (a -> m) -> URec (Ptr ()) a -> m

cfold :: (Dom (URec (Ptr ())) w, Monoid w) => URec (Ptr ()) w -> w

cfoldr :: Dom (URec (Ptr ())) a => (a -> b -> b) -> b -> URec (Ptr ()) a -> b

cfoldlM :: (Monad m, Dom (URec (Ptr ())) b) => (a -> b -> m a) -> a -> URec (Ptr ()) b -> m a

cfoldlM' :: (Monad m, Dom (URec (Ptr ())) b) => (a -> b -> m a) -> a -> URec (Ptr ()) b -> m a

cfoldrM :: (Monad m, Dom (URec (Ptr ())) a) => (a -> b -> m b) -> b -> URec (Ptr ()) a -> m b

cfoldrM' :: (Monad m, Dom (URec (Ptr ())) a) => (a -> b -> m b) -> b -> URec (Ptr ()) a -> m b

cfoldl :: Dom (URec (Ptr ())) a => (b -> a -> b) -> b -> URec (Ptr ()) a -> b

cfoldr' :: Dom (URec (Ptr ())) a => (a -> b -> b) -> b -> URec (Ptr ()) a -> b

cfoldl' :: Dom (URec (Ptr ())) a => (b -> a -> b) -> b -> URec (Ptr ()) a -> b

cbasicToList :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> [a]

cfoldr1 :: Dom (URec (Ptr ())) a => (a -> a -> a) -> URec (Ptr ()) a -> a

cfoldl1 :: Dom (URec (Ptr ())) a => (a -> a -> a) -> URec (Ptr ()) a -> a

cindex :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> Int -> a

cnull :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> Bool

clength :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> Int

cany :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> Bool

call :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> Bool

celem :: (Eq a, Dom (URec (Ptr ())) a) => a -> URec (Ptr ()) a -> Bool

cnotElem :: (Eq a, Dom (URec (Ptr ())) a) => a -> URec (Ptr ()) a -> Bool

cminimum :: (Ord a, Dom (URec (Ptr ())) a) => URec (Ptr ()) a -> a

cmaximum :: (Ord a, Dom (URec (Ptr ())) a) => URec (Ptr ()) a -> a

csum :: (Num a, Dom (URec (Ptr ())) a) => URec (Ptr ()) a -> a

cproduct :: (Num a, Dom (URec (Ptr ())) a) => URec (Ptr ()) a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec (Ptr ())) a, Dom g b) => (a -> g b) -> URec (Ptr ()) a -> g ()

ctraverse_ :: (Applicative g, Dom (URec (Ptr ())) a) => (a -> g b) -> URec (Ptr ()) a -> g ()

clast :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> a

chead :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> a

cfind :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> Maybe a

cfindIndex :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> Maybe Int

cfindIndices :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> [Int]

celemIndex :: (Dom (URec (Ptr ())) a, Eq a) => a -> URec (Ptr ()) a -> Maybe Int

celemIndices :: (Dom (URec (Ptr ())) a, Eq a) => a -> URec (Ptr ()) a -> [Int]

CFoldable (Const m :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Const m) a, Monoid w) => (a -> w) -> Const m a -> w

cfoldMap' :: (Dom (Const m) a, Monoid m0) => (a -> m0) -> Const m a -> m0

cfold :: (Dom (Const m) w, Monoid w) => Const m w -> w

cfoldr :: Dom (Const m) a => (a -> b -> b) -> b -> Const m a -> b

cfoldlM :: (Monad m0, Dom (Const m) b) => (a -> b -> m0 a) -> a -> Const m b -> m0 a

cfoldlM' :: (Monad m0, Dom (Const m) b) => (a -> b -> m0 a) -> a -> Const m b -> m0 a

cfoldrM :: (Monad m0, Dom (Const m) a) => (a -> b -> m0 b) -> b -> Const m a -> m0 b

cfoldrM' :: (Monad m0, Dom (Const m) a) => (a -> b -> m0 b) -> b -> Const m a -> m0 b

cfoldl :: Dom (Const m) a => (b -> a -> b) -> b -> Const m a -> b

cfoldr' :: Dom (Const m) a => (a -> b -> b) -> b -> Const m a -> b

cfoldl' :: Dom (Const m) a => (b -> a -> b) -> b -> Const m a -> b

cbasicToList :: Dom (Const m) a => Const m a -> [a]

cfoldr1 :: Dom (Const m) a => (a -> a -> a) -> Const m a -> a

cfoldl1 :: Dom (Const m) a => (a -> a -> a) -> Const m a -> a

cindex :: Dom (Const m) a => Const m a -> Int -> a

cnull :: Dom (Const m) a => Const m a -> Bool

clength :: Dom (Const m) a => Const m a -> Int

cany :: Dom (Const m) a => (a -> Bool) -> Const m a -> Bool

call :: Dom (Const m) a => (a -> Bool) -> Const m a -> Bool

celem :: (Eq a, Dom (Const m) a) => a -> Const m a -> Bool

cnotElem :: (Eq a, Dom (Const m) a) => a -> Const m a -> Bool

cminimum :: (Ord a, Dom (Const m) a) => Const m a -> a

cmaximum :: (Ord a, Dom (Const m) a) => Const m a -> a

csum :: (Num a, Dom (Const m) a) => Const m a -> a

cproduct :: (Num a, Dom (Const m) a) => Const m a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Const m) a, Dom g b) => (a -> g b) -> Const m a -> g ()

ctraverse_ :: (Applicative g, Dom (Const m) a) => (a -> g b) -> Const m a -> g ()

clast :: Dom (Const m) a => Const m a -> a

chead :: Dom (Const m) a => Const m a -> a

cfind :: Dom (Const m) a => (a -> Bool) -> Const m a -> Maybe a

cfindIndex :: Dom (Const m) a => (a -> Bool) -> Const m a -> Maybe Int

cfindIndices :: Dom (Const m) a => (a -> Bool) -> Const m a -> [Int]

celemIndex :: (Dom (Const m) a, Eq a) => a -> Const m a -> Maybe Int

celemIndices :: (Dom (Const m) a, Eq a) => a -> Const m a -> [Int]

CFoldable f => CFoldable (Ap f)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Ap f) a, Monoid w) => (a -> w) -> Ap f a -> w

cfoldMap' :: (Dom (Ap f) a, Monoid m) => (a -> m) -> Ap f a -> m

cfold :: (Dom (Ap f) w, Monoid w) => Ap f w -> w

cfoldr :: Dom (Ap f) a => (a -> b -> b) -> b -> Ap f a -> b

cfoldlM :: (Monad m, Dom (Ap f) b) => (a -> b -> m a) -> a -> Ap f b -> m a

cfoldlM' :: (Monad m, Dom (Ap f) b) => (a -> b -> m a) -> a -> Ap f b -> m a

cfoldrM :: (Monad m, Dom (Ap f) a) => (a -> b -> m b) -> b -> Ap f a -> m b

cfoldrM' :: (Monad m, Dom (Ap f) a) => (a -> b -> m b) -> b -> Ap f a -> m b

cfoldl :: Dom (Ap f) a => (b -> a -> b) -> b -> Ap f a -> b

cfoldr' :: Dom (Ap f) a => (a -> b -> b) -> b -> Ap f a -> b

cfoldl' :: Dom (Ap f) a => (b -> a -> b) -> b -> Ap f a -> b

cbasicToList :: Dom (Ap f) a => Ap f a -> [a]

cfoldr1 :: Dom (Ap f) a => (a -> a -> a) -> Ap f a -> a

cfoldl1 :: Dom (Ap f) a => (a -> a -> a) -> Ap f a -> a

cindex :: Dom (Ap f) a => Ap f a -> Int -> a

cnull :: Dom (Ap f) a => Ap f a -> Bool

clength :: Dom (Ap f) a => Ap f a -> Int

cany :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> Bool

call :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> Bool

celem :: (Eq a, Dom (Ap f) a) => a -> Ap f a -> Bool

cnotElem :: (Eq a, Dom (Ap f) a) => a -> Ap f a -> Bool

cminimum :: (Ord a, Dom (Ap f) a) => Ap f a -> a

cmaximum :: (Ord a, Dom (Ap f) a) => Ap f a -> a

csum :: (Num a, Dom (Ap f) a) => Ap f a -> a

cproduct :: (Num a, Dom (Ap f) a) => Ap f a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Ap f) a, Dom g b) => (a -> g b) -> Ap f a -> g ()

ctraverse_ :: (Applicative g, Dom (Ap f) a) => (a -> g b) -> Ap f a -> g ()

clast :: Dom (Ap f) a => Ap f a -> a

chead :: Dom (Ap f) a => Ap f a -> a

cfind :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> Maybe a

cfindIndex :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> Maybe Int

cfindIndices :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> [Int]

celemIndex :: (Dom (Ap f) a, Eq a) => a -> Ap f a -> Maybe Int

celemIndices :: (Dom (Ap f) a, Eq a) => a -> Ap f a -> [Int]

CFoldable f => CFoldable (Alt f)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Alt f) a, Monoid w) => (a -> w) -> Alt f a -> w

cfoldMap' :: (Dom (Alt f) a, Monoid m) => (a -> m) -> Alt f a -> m

cfold :: (Dom (Alt f) w, Monoid w) => Alt f w -> w

cfoldr :: Dom (Alt f) a => (a -> b -> b) -> b -> Alt f a -> b

cfoldlM :: (Monad m, Dom (Alt f) b) => (a -> b -> m a) -> a -> Alt f b -> m a

cfoldlM' :: (Monad m, Dom (Alt f) b) => (a -> b -> m a) -> a -> Alt f b -> m a

cfoldrM :: (Monad m, Dom (Alt f) a) => (a -> b -> m b) -> b -> Alt f a -> m b

cfoldrM' :: (Monad m, Dom (Alt f) a) => (a -> b -> m b) -> b -> Alt f a -> m b

cfoldl :: Dom (Alt f) a => (b -> a -> b) -> b -> Alt f a -> b

cfoldr' :: Dom (Alt f) a => (a -> b -> b) -> b -> Alt f a -> b

cfoldl' :: Dom (Alt f) a => (b -> a -> b) -> b -> Alt f a -> b

cbasicToList :: Dom (Alt f) a => Alt f a -> [a]

cfoldr1 :: Dom (Alt f) a => (a -> a -> a) -> Alt f a -> a

cfoldl1 :: Dom (Alt f) a => (a -> a -> a) -> Alt f a -> a

cindex :: Dom (Alt f) a => Alt f a -> Int -> a

cnull :: Dom (Alt f) a => Alt f a -> Bool

clength :: Dom (Alt f) a => Alt f a -> Int

cany :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> Bool

call :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> Bool

celem :: (Eq a, Dom (Alt f) a) => a -> Alt f a -> Bool

cnotElem :: (Eq a, Dom (Alt f) a) => a -> Alt f a -> Bool

cminimum :: (Ord a, Dom (Alt f) a) => Alt f a -> a

cmaximum :: (Ord a, Dom (Alt f) a) => Alt f a -> a

csum :: (Num a, Dom (Alt f) a) => Alt f a -> a

cproduct :: (Num a, Dom (Alt f) a) => Alt f a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Alt f) a, Dom g b) => (a -> g b) -> Alt f a -> g ()

ctraverse_ :: (Applicative g, Dom (Alt f) a) => (a -> g b) -> Alt f a -> g ()

clast :: Dom (Alt f) a => Alt f a -> a

chead :: Dom (Alt f) a => Alt f a -> a

cfind :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> Maybe a

cfindIndex :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> Maybe Int

cfindIndices :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> [Int]

celemIndex :: (Dom (Alt f) a, Eq a) => a -> Alt f a -> Maybe Int

celemIndices :: (Dom (Alt f) a, Eq a) => a -> Alt f a -> [Int]

MonoFoldable mono => CFoldable (WrapMono mono :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (WrapMono mono) a, Monoid w) => (a -> w) -> WrapMono mono a -> w

cfoldMap' :: (Dom (WrapMono mono) a, Monoid m) => (a -> m) -> WrapMono mono a -> m

cfold :: (Dom (WrapMono mono) w, Monoid w) => WrapMono mono w -> w

cfoldr :: Dom (WrapMono mono) a => (a -> b -> b) -> b -> WrapMono mono a -> b

cfoldlM :: (Monad m, Dom (WrapMono mono) b) => (a -> b -> m a) -> a -> WrapMono mono b -> m a

cfoldlM' :: (Monad m, Dom (WrapMono mono) b) => (a -> b -> m a) -> a -> WrapMono mono b -> m a

cfoldrM :: (Monad m, Dom (WrapMono mono) a) => (a -> b -> m b) -> b -> WrapMono mono a -> m b

cfoldrM' :: (Monad m, Dom (WrapMono mono) a) => (a -> b -> m b) -> b -> WrapMono mono a -> m b

cfoldl :: Dom (WrapMono mono) a => (b -> a -> b) -> b -> WrapMono mono a -> b

cfoldr' :: Dom (WrapMono mono) a => (a -> b -> b) -> b -> WrapMono mono a -> b

cfoldl' :: Dom (WrapMono mono) a => (b -> a -> b) -> b -> WrapMono mono a -> b

cbasicToList :: Dom (WrapMono mono) a => WrapMono mono a -> [a]

cfoldr1 :: Dom (WrapMono mono) a => (a -> a -> a) -> WrapMono mono a -> a

cfoldl1 :: Dom (WrapMono mono) a => (a -> a -> a) -> WrapMono mono a -> a

cindex :: Dom (WrapMono mono) a => WrapMono mono a -> Int -> a

cnull :: Dom (WrapMono mono) a => WrapMono mono a -> Bool

clength :: Dom (WrapMono mono) a => WrapMono mono a -> Int

cany :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> Bool

call :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> Bool

celem :: (Eq a, Dom (WrapMono mono) a) => a -> WrapMono mono a -> Bool

cnotElem :: (Eq a, Dom (WrapMono mono) a) => a -> WrapMono mono a -> Bool

cminimum :: (Ord a, Dom (WrapMono mono) a) => WrapMono mono a -> a

cmaximum :: (Ord a, Dom (WrapMono mono) a) => WrapMono mono a -> a

csum :: (Num a, Dom (WrapMono mono) a) => WrapMono mono a -> a

cproduct :: (Num a, Dom (WrapMono mono) a) => WrapMono mono a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (WrapMono mono) a, Dom g b) => (a -> g b) -> WrapMono mono a -> g ()

ctraverse_ :: (Applicative g, Dom (WrapMono mono) a) => (a -> g b) -> WrapMono mono a -> g ()

clast :: Dom (WrapMono mono) a => WrapMono mono a -> a

chead :: Dom (WrapMono mono) a => WrapMono mono a -> a

cfind :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> Maybe a

cfindIndex :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> Maybe Int

cfindIndices :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> [Int]

celemIndex :: (Dom (WrapMono mono) a, Eq a) => a -> WrapMono mono a -> Maybe Int

celemIndices :: (Dom (WrapMono mono) a, Eq a) => a -> WrapMono mono a -> [Int]

CFoldable (K1 i c :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (K1 i c) a, Monoid w) => (a -> w) -> K1 i c a -> w

cfoldMap' :: (Dom (K1 i c) a, Monoid m) => (a -> m) -> K1 i c a -> m

cfold :: (Dom (K1 i c) w, Monoid w) => K1 i c w -> w

cfoldr :: Dom (K1 i c) a => (a -> b -> b) -> b -> K1 i c a -> b

cfoldlM :: (Monad m, Dom (K1 i c) b) => (a -> b -> m a) -> a -> K1 i c b -> m a

cfoldlM' :: (Monad m, Dom (K1 i c) b) => (a -> b -> m a) -> a -> K1 i c b -> m a

cfoldrM :: (Monad m, Dom (K1 i c) a) => (a -> b -> m b) -> b -> K1 i c a -> m b

cfoldrM' :: (Monad m, Dom (K1 i c) a) => (a -> b -> m b) -> b -> K1 i c a -> m b

cfoldl :: Dom (K1 i c) a => (b -> a -> b) -> b -> K1 i c a -> b

cfoldr' :: Dom (K1 i c) a => (a -> b -> b) -> b -> K1 i c a -> b

cfoldl' :: Dom (K1 i c) a => (b -> a -> b) -> b -> K1 i c a -> b

cbasicToList :: Dom (K1 i c) a => K1 i c a -> [a]

cfoldr1 :: Dom (K1 i c) a => (a -> a -> a) -> K1 i c a -> a

cfoldl1 :: Dom (K1 i c) a => (a -> a -> a) -> K1 i c a -> a

cindex :: Dom (K1 i c) a => K1 i c a -> Int -> a

cnull :: Dom (K1 i c) a => K1 i c a -> Bool

clength :: Dom (K1 i c) a => K1 i c a -> Int

cany :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> Bool

call :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> Bool

celem :: (Eq a, Dom (K1 i c) a) => a -> K1 i c a -> Bool

cnotElem :: (Eq a, Dom (K1 i c) a) => a -> K1 i c a -> Bool

cminimum :: (Ord a, Dom (K1 i c) a) => K1 i c a -> a

cmaximum :: (Ord a, Dom (K1 i c) a) => K1 i c a -> a

csum :: (Num a, Dom (K1 i c) a) => K1 i c a -> a

cproduct :: (Num a, Dom (K1 i c) a) => K1 i c a -> a

cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (K1 i c) a, Dom g b) => (a -> g b) -> K1 i c a -> g ()

ctraverse_ :: (Applicative g, Dom (K1 i c) a) => (a -> g b) -> K1 i c a -> g ()

clast :: Dom (K1 i c) a => K1 i c a -> a

chead :: Dom (K1 i c) a => K1 i c a -> a

cfind :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> Maybe a

cfindIndex :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> Maybe Int

cfindIndices :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> [Int]

celemIndex :: (Dom (K1 i c) a, Eq a) => a -> K1 i c a -> Maybe Int

celemIndices :: (Dom (K1 i c) a, Eq a) => a -> K1 i c a -> [Int]

(CFoldable f, CFoldable g) => CFoldable (f :+: g)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (f :+: g) a, Monoid w) => (a -> w) -> (f :+: g) a -> w

cfoldMap' :: (Dom (f :+: g) a, Monoid m) => (a -> m) -> (f :+: g) a -> m

cfold :: (Dom (f :+: g) w, Monoid w) => (f :+: g) w -> w

cfoldr :: Dom (f :+: g) a => (a -> b -> b) -> b -> (f :+: g) a -> b

cfoldlM :: (Monad m, Dom (f :+: g) b) => (a -> b -> m a) -> a -> (f :+: g) b -> m a

cfoldlM' :: (Monad m, Dom (f :+: g) b) => (a -> b -> m a) -> a -> (f :+: g) b -> m a

cfoldrM :: (Monad m, Dom (f :+: g) a) => (a -> b -> m b) -> b -> (f :+: g) a -> m b

cfoldrM' :: (Monad m, Dom (f :+: g) a) => (a -> b -> m b) -> b -> (f :+: g) a -> m b

cfoldl :: Dom (f :+: g) a => (b -> a -> b) -> b -> (f :+: g) a -> b

cfoldr' :: Dom (f :+: g) a => (a -> b -> b) -> b -> (f :+: g) a -> b

cfoldl' :: Dom (f :+: g) a => (b -> a -> b) -> b -> (f :+: g) a -> b

cbasicToList :: Dom (f :+: g) a => (f :+: g) a -> [a]

cfoldr1 :: Dom (f :+: g) a => (a -> a -> a) -> (f :+: g) a -> a

cfoldl1 :: Dom (f :+: g) a => (a -> a -> a) -> (f :+: g) a -> a

cindex :: Dom (f :+: g) a => (f :+: g) a -> Int -> a

cnull :: Dom (f :+: g) a => (f :+: g) a -> Bool

clength :: Dom (f :+: g) a => (f :+: g) a -> Int

cany :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> Bool

call :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> Bool

celem :: (Eq a, Dom (f :+: g) a) => a -> (f :+: g) a -> Bool

cnotElem :: (Eq a, Dom (f :+: g) a) => a -> (f :+: g) a -> Bool

cminimum :: (Ord a, Dom (f :+: g) a) => (f :+: g) a -> a

cmaximum :: (Ord a, Dom (f :+: g) a) => (f :+: g) a -> a

csum :: (Num a, Dom (f :+: g) a) => (f :+: g) a -> a

cproduct :: (Num a, Dom (f :+: g) a) => (f :+: g) a -> a

cctraverse_ :: (CApplicative g0, CPointed g0, Dom g0 (), Dom (f :+: g) a, Dom g0 b) => (a -> g0 b) -> (f :+: g) a -> g0 ()

ctraverse_ :: (Applicative g0, Dom (f :+: g) a) => (a -> g0 b) -> (f :+: g) a -> g0 ()

clast :: Dom (f :+: g) a => (f :+: g) a -> a

chead :: Dom (f :+: g) a => (f :+: g) a -> a

cfind :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> Maybe a

cfindIndex :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> Maybe Int

cfindIndices :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> [Int]

celemIndex :: (Dom (f :+: g) a, Eq a) => a -> (f :+: g) a -> Maybe Int

celemIndices :: (Dom (f :+: g) a, Eq a) => a -> (f :+: g) a -> [Int]

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

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (f :*: g) a, Monoid w) => (a -> w) -> (f :*: g) a -> w

cfoldMap' :: (Dom (f :*: g) a, Monoid m) => (a -> m) -> (f :*: g) a -> m

cfold :: (Dom (f :*: g) w, Monoid w) => (f :*: g) w -> w

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

cfoldlM :: (Monad m, Dom (f :*: g) b) => (a -> b -> m a) -> a -> (f :*: g) b -> m a

cfoldlM' :: (Monad m, Dom (f :*: g) b) => (a -> b -> m a) -> a -> (f :*: g) b -> m a

cfoldrM :: (Monad m, Dom (f :*: g) a) => (a -> b -> m b) -> b -> (f :*: g) a -> m b

cfoldrM' :: (Monad m, Dom (f :*: g) a) => (a -> b -> m b) -> b -> (f :*: g) a -> m b

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

cfoldr' :: Dom (f :*: g) a => (a -> b -> b) -> b -> (f :*: g) a -> b

cfoldl' :: Dom (f :*: g) a => (b -> a -> b) -> b -> (f :*: g) a -> b

cbasicToList :: Dom (f :*: g) a => (f :*: g) a -> [a]

cfoldr1 :: Dom (f :*: g) a => (a -> a -> a) -> (f :*: g) a -> a

cfoldl1 :: Dom (f :*: g) a => (a -> a -> a) -> (f :*: g) a -> a

cindex :: Dom (f :*: g) a => (f :*: g) a -> Int -> a

cnull :: Dom (f :*: g) a => (f :*: g) a -> Bool

clength :: Dom (f :*: g) a => (f :*: g) a -> Int

cany :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> Bool

call :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> Bool

celem :: (Eq a, Dom (f :*: g) a) => a -> (f :*: g) a -> Bool

cnotElem :: (Eq a, Dom (f :*: g) a) => a -> (f :*: g) a -> Bool

cminimum :: (Ord a, Dom (f :*: g) a) => (f :*: g) a -> a

cmaximum :: (Ord a, Dom (f :*: g) a) => (f :*: g) a -> a

csum :: (Num a, Dom (f :*: g) a) => (f :*: g) a -> a

cproduct :: (Num a, Dom (f :*: g) a) => (f :*: g) a -> a

cctraverse_ :: (CApplicative g0, CPointed g0, Dom g0 (), Dom (f :*: g) a, Dom g0 b) => (a -> g0 b) -> (f :*: g) a -> g0 ()

ctraverse_ :: (Applicative g0, Dom (f :*: g) a) => (a -> g0 b) -> (f :*: g) a -> g0 ()

clast :: Dom (f :*: g) a => (f :*: g) a -> a

chead :: Dom (f :*: g) a => (f :*: g) a -> a

cfind :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> Maybe a

cfindIndex :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> Maybe Int

cfindIndices :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> [Int]

celemIndex :: (Dom (f :*: g) a, Eq a) => a -> (f :*: g) a -> Maybe Int

celemIndices :: (Dom (f :*: g) a, Eq a) => a -> (f :*: g) a -> [Int]

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

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Product f g) a, Monoid w) => (a -> w) -> Product f g a -> w

cfoldMap' :: (Dom (Product f g) a, Monoid m) => (a -> m) -> Product f g a -> m

cfold :: (Dom (Product f g) w, Monoid w) => Product f g w -> w

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

cfoldlM :: (Monad m, Dom (Product f g) b) => (a -> b -> m a) -> a -> Product f g b -> m a

cfoldlM' :: (Monad m, Dom (Product f g) b) => (a -> b -> m a) -> a -> Product f g b -> m a

cfoldrM :: (Monad m, Dom (Product f g) a) => (a -> b -> m b) -> b -> Product f g a -> m b

cfoldrM' :: (Monad m, Dom (Product f g) a) => (a -> b -> m b) -> b -> Product f g a -> m b

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

cfoldr' :: Dom (Product f g) a => (a -> b -> b) -> b -> Product f g a -> b

cfoldl' :: Dom (Product f g) a => (b -> a -> b) -> b -> Product f g a -> b

cbasicToList :: Dom (Product f g) a => Product f g a -> [a]

cfoldr1 :: Dom (Product f g) a => (a -> a -> a) -> Product f g a -> a

cfoldl1 :: Dom (Product f g) a => (a -> a -> a) -> Product f g a -> a

cindex :: Dom (Product f g) a => Product f g a -> Int -> a

cnull :: Dom (Product f g) a => Product f g a -> Bool

clength :: Dom (Product f g) a => Product f g a -> Int

cany :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> Bool

call :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> Bool

celem :: (Eq a, Dom (Product f g) a) => a -> Product f g a -> Bool

cnotElem :: (Eq a, Dom (Product f g) a) => a -> Product f g a -> Bool

cminimum :: (Ord a, Dom (Product f g) a) => Product f g a -> a

cmaximum :: (Ord a, Dom (Product f g) a) => Product f g a -> a

csum :: (Num a, Dom (Product f g) a) => Product f g a -> a

cproduct :: (Num a, Dom (Product f g) a) => Product f g a -> a

cctraverse_ :: (CApplicative g0, CPointed g0, Dom g0 (), Dom (Product f g) a, Dom g0 b) => (a -> g0 b) -> Product f g a -> g0 ()

ctraverse_ :: (Applicative g0, Dom (Product f g) a) => (a -> g0 b) -> Product f g a -> g0 ()

clast :: Dom (Product f g) a => Product f g a -> a

chead :: Dom (Product f g) a => Product f g a -> a

cfind :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> Maybe a

cfindIndex :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> Maybe Int

cfindIndices :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> [Int]

celemIndex :: (Dom (Product f g) a, Eq a) => a -> Product f g a -> Maybe Int

celemIndices :: (Dom (Product f g) a, Eq a) => a -> Product f g a -> [Int]

(CFoldable f, CFoldable g) => CFoldable (Sum f g)

Defined in Control.Subcategory.Foldable

Methods

cfoldMap :: (Dom (Sum f g) a, Monoid w) => (a -> w) -> Sum f g a -> w

cfoldMap' :: (Dom (Sum f g) a, Monoid m) => (a -> m) -> Sum f g a -> m

cfold :: (Dom (Sum f g) w, Monoid w) => Sum f g w -> w

cfoldr :: Dom (Sum f g) a => (a -> b -> b) -> b -> Sum f g a -> b

cfoldlM :: (Monad m, Dom (Sum f g) b) => (a -> b -> m a) -> a -> Sum f g b -> m a

cfoldlM' :: (Monad m, Dom (Sum f g) b) => (a -> b -> m a) -> a -> Sum f g b -> m a

cfoldrM :: (Monad m, Dom (Sum f g) a) => (a -> b -> m b) -> b -> Sum f g a -> m b

cfoldrM' :: (Monad m, Dom (Sum f g) a) => (a -> b -> m b) -> b -> Sum f g a -> m b

cfoldl :: Dom (Sum f g) a => (b -> a -> b) -> b -> Sum f g a -> b

cfoldr' :: Dom (Sum f g) a => (a -> b -> b) -> b -> Sum f g a -> b

cfoldl' :: Dom (Sum f g) a => (b -> a -> b) -> b -> Sum f g a -> b

cbasicToList :: Dom (Sum f g) a => Sum f g a -> [a]

cfoldr1 :: Dom (Sum f g) a => (a -> a -> a) -> Sum f g a -> a

cfoldl1 :: Dom (Sum f g) a => (a -> a -> a) -> Sum f g a -> a

cindex :: Dom (Sum f g) a => Sum f g a -> Int -> a

cnull :: Dom (Sum f g) a => Sum f g a -> Bool

clength :: Dom (Sum f g) a => Sum f g a -> Int

cany :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Bool

call :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Bool

celem :: (Eq a, Dom (Sum f g) a) => a -> Sum f g a -> Bool

cnotElem :: (Eq a, Dom (Sum f g) a) => a -> Sum f g a -> Bool

cminimum :: (Ord a, Dom (Sum f g) a) => Sum f g a -> a

cmaximum :: (Ord a, Dom (Sum f g) a) => Sum f g a -> a

csum :: (Num a, Dom (Sum f g) a) => Sum f g a -> a

cproduct :: (Num a, Dom (Sum f g) a) => Sum f g a -> a

cctraverse_ :: (CApplicative g0, CPointed g0, Dom g0 (), Dom (Sum f g) a, Dom g0 b) => (a -> g0 b) -> Sum f g a -> g0 ()

ctraverse_ :: (Applicative g0, Dom (Sum f g) a) => (a -> g0 b) -> Sum f g a -> g0 ()

clast :: Dom (Sum f g) a => Sum f g a -> a

chead :: Dom (Sum f g) a => Sum f g a -> a

cfind :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Maybe a

cfindIndex :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Maybe Int

cfindIndices :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> [Int]

celemIndex :: (Dom (Sum f g) a, Eq a) => a -> Sum f g a -> Maybe Int

celemIndices :: (Dom (Sum f g) a, Eq a) => a -> Sum f g a -> [Int]

ctoList :: (CFoldable f, Dom f a) => f a -> [a]

class (CFunctor f, CFoldable f) => CTraversable f where

Methods

ctraverse :: (Dom f a, Dom f b, Applicative g) => (a -> g b) -> f a -> g (f b)

N.B. If we require g to be CApplicative we cannot directly lift plain Traversable to CTraversable. This is rather annoying, so we require the strongest possible constraint to g here.

Instances

CTraversable []

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom [] a, Dom [] b, Applicative g) => (a -> g b) -> [a] -> g [b]

CTraversable Maybe

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Maybe a, Dom Maybe b, Applicative g) => (a -> g b) -> Maybe a -> g (Maybe b)

CTraversable Par1

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Par1 a, Dom Par1 b, Applicative g) => (a -> g b) -> Par1 a -> g (Par1 b)

CTraversable Complex

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Complex a, Dom Complex b, Applicative g) => (a -> g b) -> Complex a -> g (Complex b)

CTraversable Min

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Min a, Dom Min b, Applicative g) => (a -> g b) -> Min a -> g (Min b)

CTraversable Max

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Max a, Dom Max b, Applicative g) => (a -> g b) -> Max a -> g (Max b)

CTraversable First

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom First a, Dom First b, Applicative g) => (a -> g b) -> First a -> g (First b)

CTraversable Last

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Last a, Dom Last b, Applicative g) => (a -> g b) -> Last a -> g (Last b)

CTraversable Option

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Option a, Dom Option b, Applicative g) => (a -> g b) -> Option a -> g (Option b)

CTraversable ZipList

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom ZipList a, Dom ZipList b, Applicative g) => (a -> g b) -> ZipList a -> g (ZipList b)

CTraversable Identity

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Identity a, Dom Identity b, Applicative g) => (a -> g b) -> Identity a -> g (Identity b)

CTraversable First

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom First a, Dom First b, Applicative g) => (a -> g b) -> First a -> g (First b)

CTraversable Last

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Last a, Dom Last b, Applicative g) => (a -> g b) -> Last a -> g (Last b)

CTraversable Down

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Down a, Dom Down b, Applicative g) => (a -> g b) -> Down a -> g (Down b)

CTraversable NonEmpty

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom NonEmpty a, Dom NonEmpty b, Applicative g) => (a -> g b) -> NonEmpty a -> g (NonEmpty b)

CTraversable IntMap

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom IntMap a, Dom IntMap b, Applicative g) => (a -> g b) -> IntMap a -> g (IntMap b)

CTraversable Seq

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Seq a, Dom Seq b, Applicative g) => (a -> g b) -> Seq a -> g (Seq b)

CTraversable Set

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Set a, Dom Set b, Applicative g) => (a -> g b) -> Set a -> g (Set b)

CTraversable PrimArray

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom PrimArray a, Dom PrimArray b, Applicative g) => (a -> g b) -> PrimArray a -> g (PrimArray b)

CTraversable SmallArray

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom SmallArray a, Dom SmallArray b, Applicative g) => (a -> g b) -> SmallArray a -> g (SmallArray b)

CTraversable Array

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Array a, Dom Array b, Applicative g) => (a -> g b) -> Array a -> g (Array b)

CTraversable HashSet

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom HashSet a, Dom HashSet b, Applicative g) => (a -> g b) -> HashSet a -> g (HashSet b)

CTraversable Vector

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Vector a, Dom Vector b, Applicative g) => (a -> g b) -> Vector a -> g (Vector b)

CTraversable Vector

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Vector a, Dom Vector b, Applicative g) => (a -> g b) -> Vector a -> g (Vector b)

CTraversable Vector

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Vector a, Dom Vector b, Applicative g) => (a -> g b) -> Vector a -> g (Vector b)

CTraversable Vector

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Vector a, Dom Vector b, Applicative g) => (a -> g b) -> Vector a -> g (Vector b)

CTraversable (Either e)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (Either e) a, Dom (Either e) b, Applicative g) => (a -> g b) -> Either e a -> g (Either e b)

CTraversable (V1 :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom V1 a, Dom V1 b, Applicative g) => (a -> g b) -> V1 a -> g (V1 b)

CTraversable (U1 :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom U1 a, Dom U1 b, Applicative g) => (a -> g b) -> U1 a -> g (U1 b)

CTraversable ((,) a)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom ((,) a) a0, Dom ((,) a) b, Applicative g) => (a0 -> g b) -> (a, a0) -> g (a, b)

CTraversable (Arg a)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (Arg a) a0, Dom (Arg a) b, Applicative g) => (a0 -> g b) -> Arg a a0 -> g (Arg a b)

CTraversable (Proxy :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom Proxy a, Dom Proxy b, Applicative g) => (a -> g b) -> Proxy a -> g (Proxy b)

Ord k => CTraversable (Map k)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (Map k) a, Dom (Map k) b, Applicative g) => (a -> g b) -> Map k a -> g (Map k b)

CTraversable (HashMap k)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (HashMap k) a, Dom (HashMap k) b, Applicative g) => (a -> g b) -> HashMap k a -> g (HashMap k b)

Traversable f => CTraversable (WrapFunctor f)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (WrapFunctor f) a, Dom (WrapFunctor f) b, Applicative g) => (a -> g b) -> WrapFunctor f a -> g (WrapFunctor f b)

CTraversable (URec Char :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (URec Char) a, Dom (URec Char) b, Applicative g) => (a -> g b) -> URec Char a -> g (URec Char b)

CTraversable (URec Double :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (URec Double) a, Dom (URec Double) b, Applicative g) => (a -> g b) -> URec Double a -> g (URec Double b)

CTraversable (URec Float :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (URec Float) a, Dom (URec Float) b, Applicative g) => (a -> g b) -> URec Float a -> g (URec Float b)

CTraversable (URec Int :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (URec Int) a, Dom (URec Int) b, Applicative g) => (a -> g b) -> URec Int a -> g (URec Int b)

CTraversable (URec Word :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (URec Word) a, Dom (URec Word) b, Applicative g) => (a -> g b) -> URec Word a -> g (URec Word b)

CTraversable (URec (Ptr ()) :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (URec (Ptr ())) a, Dom (URec (Ptr ())) b, Applicative g) => (a -> g b) -> URec (Ptr ()) a -> g (URec (Ptr ()) b)

CTraversable (Const m :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (Const m) a, Dom (Const m) b, Applicative g) => (a -> g b) -> Const m a -> g (Const m b)

MonoTraversable mono => CTraversable (WrapMono mono :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (WrapMono mono) a, Dom (WrapMono mono) b, Applicative g) => (a -> g b) -> WrapMono mono a -> g (WrapMono mono b)

CTraversable (K1 i c :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (K1 i c) a, Dom (K1 i c) b, Applicative g) => (a -> g b) -> K1 i c a -> g (K1 i c b)

(CTraversable f, CTraversable g) => CTraversable (f :+: g)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (f :+: g) a, Dom (f :+: g) b, Applicative g0) => (a -> g0 b) -> (f :+: g) a -> g0 ((f :+: g) b)

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

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (f :*: g) a, Dom (f :*: g) b, Applicative g0) => (a -> g0 b) -> (f :*: g) a -> g0 ((f :*: g) b)

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

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (Product f g) a, Dom (Product f g) b, Applicative g0) => (a -> g0 b) -> Product f g a -> g0 (Product f g b)

(CTraversable f, CTraversable g) => CTraversable (Sum f g)

Defined in Control.Subcategory.Foldable

Methods

ctraverse :: (Dom (Sum f g) a, Dom (Sum f g) b, Applicative g0) => (a -> g0 b) -> Sum f g a -> g0 (Sum f g b)

class (CFunctor f, forall x. Dom f x => Monoid (f x), CPointed f, CFoldable f) => CFreeMonoid f where

Free monoid functor from fullsubcategory. It must be a pointed foldable functor with the property that for any Monoid w and f :: a -> w, cfoldMap f must be a monoid homomorphism and the following must be hold:

      cfoldMap f . cpure == f
   

Hence, Sets cannot be a free monoid functor;

Minimal complete definition

Nothing

Methods

cbasicFromList :: Dom f a => [a] -> f a

ccons :: Dom f a => a -> f a -> f a

csnoc :: Dom f a => f a -> a -> f a

cfromListN :: Dom f a => Int -> [a] -> f a

The cfromListN function takes the input list's length as a hint. Its behaviour should be equivalent to cfromList. The hint can be used to construct the structure l more efficiently compared to cfromList. If the given hint does not equal to the input list's length the behaviour of fromListN is not specified.

ctake :: Dom f a => Int -> f a -> f a

cdrop :: Dom f a => Int -> f a -> f a

cinit :: Dom f a => f a -> f a

ctail :: Dom f a => f a -> f a

csplitAt :: Dom f a => Int -> f a -> (f a, f a)

creplicate :: Dom f a => Int -> a -> f a

cgenerate :: Dom f a => Int -> (Int -> a) -> f a

cgenerateM :: (Dom f a, Monad m) => Int -> (Int -> m a) -> m (f a)

cgenerateA :: (Dom f a, Applicative g) => Int -> (Int -> g a) -> g (f a)

cuncons :: Dom f a => f a -> Maybe (a, f a)

cunsnoc :: Dom f a => f a -> Maybe (f a, a)

creverse :: Dom f a => f a -> f a

cintersperse :: Dom f a => a -> f a -> f a

cnub :: (Dom f a, Eq a) => f a -> f a

cnubOrd :: (Dom f a, Ord a) => f a -> f a

csort :: (Dom f a, Ord a) => f a -> f a

csortBy :: Dom f a => (a -> a -> Ordering) -> f a -> f a

cinsert :: (Dom f a, Ord a) => a -> f a -> f a

cinsertBy :: Dom f a => (a -> a -> Ordering) -> a -> f a -> f a

ctakeWhile :: Dom f a => (a -> Bool) -> f a -> f a

cdropWhile :: Dom f a => (a -> Bool) -> f a -> f a

cspan :: Dom f a => (a -> Bool) -> f a -> (f a, f a)

cbreak :: Dom f a => (a -> Bool) -> f a -> (f a, f a)

cfilter :: Dom f a => (a -> Bool) -> f a -> f a

cpartition :: Dom f a => (a -> Bool) -> f a -> (f a, f a)

Instances

CFreeMonoid []

Defined in Control.Subcategory.Foldable

Methods

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

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

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

cfromListN :: Dom [] a => Int -> [a] -> [a]

ctake :: Dom [] a => Int -> [a] -> [a]

cdrop :: Dom [] a => Int -> [a] -> [a]

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

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

csplitAt :: Dom [] a => Int -> [a] -> ([a], [a])

creplicate :: Dom [] a => Int -> a -> [a]

cgenerate :: Dom [] a => Int -> (Int -> a) -> [a]

cgenerateM :: (Dom [] a, Monad m) => Int -> (Int -> m a) -> m [a]

cgenerateA :: (Dom [] a, Applicative g) => Int -> (Int -> g a) -> g [a]

cuncons :: Dom [] a => [a] -> Maybe (a, [a])

cunsnoc :: Dom [] a => [a] -> Maybe ([a], a)

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

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

cnub :: (Dom [] a, Eq a) => [a] -> [a]

cnubOrd :: (Dom [] a, Ord a) => [a] -> [a]

csort :: (Dom [] a, Ord a) => [a] -> [a]

csortBy :: Dom [] a => (a -> a -> Ordering) -> [a] -> [a]

cinsert :: (Dom [] a, Ord a) => a -> [a] -> [a]

cinsertBy :: Dom [] a => (a -> a -> Ordering) -> a -> [a] -> [a]

ctakeWhile :: Dom [] a => (a -> Bool) -> [a] -> [a]

cdropWhile :: Dom [] a => (a -> Bool) -> [a] -> [a]

cspan :: Dom [] a => (a -> Bool) -> [a] -> ([a], [a])

cbreak :: Dom [] a => (a -> Bool) -> [a] -> ([a], [a])

cfilter :: Dom [] a => (a -> Bool) -> [a] -> [a]

cpartition :: Dom [] a => (a -> Bool) -> [a] -> ([a], [a])

CFreeMonoid Seq

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom Seq a => [a] -> Seq a

ccons :: Dom Seq a => a -> Seq a -> Seq a

csnoc :: Dom Seq a => Seq a -> a -> Seq a

cfromListN :: Dom Seq a => Int -> [a] -> Seq a

ctake :: Dom Seq a => Int -> Seq a -> Seq a

cdrop :: Dom Seq a => Int -> Seq a -> Seq a

cinit :: Dom Seq a => Seq a -> Seq a

ctail :: Dom Seq a => Seq a -> Seq a

csplitAt :: Dom Seq a => Int -> Seq a -> (Seq a, Seq a)

creplicate :: Dom Seq a => Int -> a -> Seq a

cgenerate :: Dom Seq a => Int -> (Int -> a) -> Seq a

cgenerateM :: (Dom Seq a, Monad m) => Int -> (Int -> m a) -> m (Seq a)

cgenerateA :: (Dom Seq a, Applicative g) => Int -> (Int -> g a) -> g (Seq a)

cuncons :: Dom Seq a => Seq a -> Maybe (a, Seq a)

cunsnoc :: Dom Seq a => Seq a -> Maybe (Seq a, a)

creverse :: Dom Seq a => Seq a -> Seq a

cintersperse :: Dom Seq a => a -> Seq a -> Seq a

cnub :: (Dom Seq a, Eq a) => Seq a -> Seq a

cnubOrd :: (Dom Seq a, Ord a) => Seq a -> Seq a

csort :: (Dom Seq a, Ord a) => Seq a -> Seq a

csortBy :: Dom Seq a => (a -> a -> Ordering) -> Seq a -> Seq a

cinsert :: (Dom Seq a, Ord a) => a -> Seq a -> Seq a

cinsertBy :: Dom Seq a => (a -> a -> Ordering) -> a -> Seq a -> Seq a

ctakeWhile :: Dom Seq a => (a -> Bool) -> Seq a -> Seq a

cdropWhile :: Dom Seq a => (a -> Bool) -> Seq a -> Seq a

cspan :: Dom Seq a => (a -> Bool) -> Seq a -> (Seq a, Seq a)

cbreak :: Dom Seq a => (a -> Bool) -> Seq a -> (Seq a, Seq a)

cfilter :: Dom Seq a => (a -> Bool) -> Seq a -> Seq a

cpartition :: Dom Seq a => (a -> Bool) -> Seq a -> (Seq a, Seq a)

CFreeMonoid PrimArray

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom PrimArray a => [a] -> PrimArray a

ccons :: Dom PrimArray a => a -> PrimArray a -> PrimArray a

csnoc :: Dom PrimArray a => PrimArray a -> a -> PrimArray a

cfromListN :: Dom PrimArray a => Int -> [a] -> PrimArray a

ctake :: Dom PrimArray a => Int -> PrimArray a -> PrimArray a

cdrop :: Dom PrimArray a => Int -> PrimArray a -> PrimArray a

cinit :: Dom PrimArray a => PrimArray a -> PrimArray a

ctail :: Dom PrimArray a => PrimArray a -> PrimArray a

csplitAt :: Dom PrimArray a => Int -> PrimArray a -> (PrimArray a, PrimArray a)

creplicate :: Dom PrimArray a => Int -> a -> PrimArray a

cgenerate :: Dom PrimArray a => Int -> (Int -> a) -> PrimArray a

cgenerateM :: (Dom PrimArray a, Monad m) => Int -> (Int -> m a) -> m (PrimArray a)

cgenerateA :: (Dom PrimArray a, Applicative g) => Int -> (Int -> g a) -> g (PrimArray a)

cuncons :: Dom PrimArray a => PrimArray a -> Maybe (a, PrimArray a)

cunsnoc :: Dom PrimArray a => PrimArray a -> Maybe (PrimArray a, a)

creverse :: Dom PrimArray a => PrimArray a -> PrimArray a

cintersperse :: Dom PrimArray a => a -> PrimArray a -> PrimArray a

cnub :: (Dom PrimArray a, Eq a) => PrimArray a -> PrimArray a

cnubOrd :: (Dom PrimArray a, Ord a) => PrimArray a -> PrimArray a

csort :: (Dom PrimArray a, Ord a) => PrimArray a -> PrimArray a

csortBy :: Dom PrimArray a => (a -> a -> Ordering) -> PrimArray a -> PrimArray a

cinsert :: (Dom PrimArray a, Ord a) => a -> PrimArray a -> PrimArray a

cinsertBy :: Dom PrimArray a => (a -> a -> Ordering) -> a -> PrimArray a -> PrimArray a

ctakeWhile :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> PrimArray a

cdropWhile :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> PrimArray a

cspan :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> (PrimArray a, PrimArray a)

cbreak :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> (PrimArray a, PrimArray a)

cfilter :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> PrimArray a

cpartition :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> (PrimArray a, PrimArray a)

CFreeMonoid SmallArray

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom SmallArray a => [a] -> SmallArray a

ccons :: Dom SmallArray a => a -> SmallArray a -> SmallArray a

csnoc :: Dom SmallArray a => SmallArray a -> a -> SmallArray a

cfromListN :: Dom SmallArray a => Int -> [a] -> SmallArray a

ctake :: Dom SmallArray a => Int -> SmallArray a -> SmallArray a

cdrop :: Dom SmallArray a => Int -> SmallArray a -> SmallArray a

cinit :: Dom SmallArray a => SmallArray a -> SmallArray a

ctail :: Dom SmallArray a => SmallArray a -> SmallArray a

csplitAt :: Dom SmallArray a => Int -> SmallArray a -> (SmallArray a, SmallArray a)

creplicate :: Dom SmallArray a => Int -> a -> SmallArray a

cgenerate :: Dom SmallArray a => Int -> (Int -> a) -> SmallArray a

cgenerateM :: (Dom SmallArray a, Monad m) => Int -> (Int -> m a) -> m (SmallArray a)

cgenerateA :: (Dom SmallArray a, Applicative g) => Int -> (Int -> g a) -> g (SmallArray a)

cuncons :: Dom SmallArray a => SmallArray a -> Maybe (a, SmallArray a)

cunsnoc :: Dom SmallArray a => SmallArray a -> Maybe (SmallArray a, a)

creverse :: Dom SmallArray a => SmallArray a -> SmallArray a

cintersperse :: Dom SmallArray a => a -> SmallArray a -> SmallArray a

cnub :: (Dom SmallArray a, Eq a) => SmallArray a -> SmallArray a

cnubOrd :: (Dom SmallArray a, Ord a) => SmallArray a -> SmallArray a

csort :: (Dom SmallArray a, Ord a) => SmallArray a -> SmallArray a

csortBy :: Dom SmallArray a => (a -> a -> Ordering) -> SmallArray a -> SmallArray a

cinsert :: (Dom SmallArray a, Ord a) => a -> SmallArray a -> SmallArray a

cinsertBy :: Dom SmallArray a => (a -> a -> Ordering) -> a -> SmallArray a -> SmallArray a

ctakeWhile :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> SmallArray a

cdropWhile :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> SmallArray a

cspan :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> (SmallArray a, SmallArray a)

cbreak :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> (SmallArray a, SmallArray a)

cfilter :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> SmallArray a

cpartition :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> (SmallArray a, SmallArray a)

CFreeMonoid Array

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom Array a => [a] -> Array a

ccons :: Dom Array a => a -> Array a -> Array a

csnoc :: Dom Array a => Array a -> a -> Array a

cfromListN :: Dom Array a => Int -> [a] -> Array a

ctake :: Dom Array a => Int -> Array a -> Array a

cdrop :: Dom Array a => Int -> Array a -> Array a

cinit :: Dom Array a => Array a -> Array a

ctail :: Dom Array a => Array a -> Array a

csplitAt :: Dom Array a => Int -> Array a -> (Array a, Array a)

creplicate :: Dom Array a => Int -> a -> Array a

cgenerate :: Dom Array a => Int -> (Int -> a) -> Array a

cgenerateM :: (Dom Array a, Monad m) => Int -> (Int -> m a) -> m (Array a)

cgenerateA :: (Dom Array a, Applicative g) => Int -> (Int -> g a) -> g (Array a)

cuncons :: Dom Array a => Array a -> Maybe (a, Array a)

cunsnoc :: Dom Array a => Array a -> Maybe (Array a, a)

creverse :: Dom Array a => Array a -> Array a

cintersperse :: Dom Array a => a -> Array a -> Array a

cnub :: (Dom Array a, Eq a) => Array a -> Array a

cnubOrd :: (Dom Array a, Ord a) => Array a -> Array a

csort :: (Dom Array a, Ord a) => Array a -> Array a

csortBy :: Dom Array a => (a -> a -> Ordering) -> Array a -> Array a

cinsert :: (Dom Array a, Ord a) => a -> Array a -> Array a

cinsertBy :: Dom Array a => (a -> a -> Ordering) -> a -> Array a -> Array a

ctakeWhile :: Dom Array a => (a -> Bool) -> Array a -> Array a

cdropWhile :: Dom Array a => (a -> Bool) -> Array a -> Array a

cspan :: Dom Array a => (a -> Bool) -> Array a -> (Array a, Array a)

cbreak :: Dom Array a => (a -> Bool) -> Array a -> (Array a, Array a)

cfilter :: Dom Array a => (a -> Bool) -> Array a -> Array a

cpartition :: Dom Array a => (a -> Bool) -> Array a -> (Array a, Array a)

CFreeMonoid Vector

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom Vector a => [a] -> Vector a

ccons :: Dom Vector a => a -> Vector a -> Vector a

csnoc :: Dom Vector a => Vector a -> a -> Vector a

cfromListN :: Dom Vector a => Int -> [a] -> Vector a

ctake :: Dom Vector a => Int -> Vector a -> Vector a

cdrop :: Dom Vector a => Int -> Vector a -> Vector a

cinit :: Dom Vector a => Vector a -> Vector a

ctail :: Dom Vector a => Vector a -> Vector a

csplitAt :: Dom Vector a => Int -> Vector a -> (Vector a, Vector a)

creplicate :: Dom Vector a => Int -> a -> Vector a

cgenerate :: Dom Vector a => Int -> (Int -> a) -> Vector a

cgenerateM :: (Dom Vector a, Monad m) => Int -> (Int -> m a) -> m (Vector a)

cgenerateA :: (Dom Vector a, Applicative g) => Int -> (Int -> g a) -> g (Vector a)

cuncons :: Dom Vector a => Vector a -> Maybe (a, Vector a)

cunsnoc :: Dom Vector a => Vector a -> Maybe (Vector a, a)

creverse :: Dom Vector a => Vector a -> Vector a

cintersperse :: Dom Vector a => a -> Vector a -> Vector a

cnub :: (Dom Vector a, Eq a) => Vector a -> Vector a

cnubOrd :: (Dom Vector a, Ord a) => Vector a -> Vector a

csort :: (Dom Vector a, Ord a) => Vector a -> Vector a

csortBy :: Dom Vector a => (a -> a -> Ordering) -> Vector a -> Vector a

cinsert :: (Dom Vector a, Ord a) => a -> Vector a -> Vector a

cinsertBy :: Dom Vector a => (a -> a -> Ordering) -> a -> Vector a -> Vector a

ctakeWhile :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cdropWhile :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cspan :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

cbreak :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

cfilter :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cpartition :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

CFreeMonoid Vector

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom Vector a => [a] -> Vector a

ccons :: Dom Vector a => a -> Vector a -> Vector a

csnoc :: Dom Vector a => Vector a -> a -> Vector a

cfromListN :: Dom Vector a => Int -> [a] -> Vector a

ctake :: Dom Vector a => Int -> Vector a -> Vector a

cdrop :: Dom Vector a => Int -> Vector a -> Vector a

cinit :: Dom Vector a => Vector a -> Vector a

ctail :: Dom Vector a => Vector a -> Vector a

csplitAt :: Dom Vector a => Int -> Vector a -> (Vector a, Vector a)

creplicate :: Dom Vector a => Int -> a -> Vector a

cgenerate :: Dom Vector a => Int -> (Int -> a) -> Vector a

cgenerateM :: (Dom Vector a, Monad m) => Int -> (Int -> m a) -> m (Vector a)

cgenerateA :: (Dom Vector a, Applicative g) => Int -> (Int -> g a) -> g (Vector a)

cuncons :: Dom Vector a => Vector a -> Maybe (a, Vector a)

cunsnoc :: Dom Vector a => Vector a -> Maybe (Vector a, a)

creverse :: Dom Vector a => Vector a -> Vector a

cintersperse :: Dom Vector a => a -> Vector a -> Vector a

cnub :: (Dom Vector a, Eq a) => Vector a -> Vector a

cnubOrd :: (Dom Vector a, Ord a) => Vector a -> Vector a

csort :: (Dom Vector a, Ord a) => Vector a -> Vector a

csortBy :: Dom Vector a => (a -> a -> Ordering) -> Vector a -> Vector a

cinsert :: (Dom Vector a, Ord a) => a -> Vector a -> Vector a

cinsertBy :: Dom Vector a => (a -> a -> Ordering) -> a -> Vector a -> Vector a

ctakeWhile :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cdropWhile :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cspan :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

cbreak :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

cfilter :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cpartition :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

CFreeMonoid Vector

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom Vector a => [a] -> Vector a

ccons :: Dom Vector a => a -> Vector a -> Vector a

csnoc :: Dom Vector a => Vector a -> a -> Vector a

cfromListN :: Dom Vector a => Int -> [a] -> Vector a

ctake :: Dom Vector a => Int -> Vector a -> Vector a

cdrop :: Dom Vector a => Int -> Vector a -> Vector a

cinit :: Dom Vector a => Vector a -> Vector a

ctail :: Dom Vector a => Vector a -> Vector a

csplitAt :: Dom Vector a => Int -> Vector a -> (Vector a, Vector a)

creplicate :: Dom Vector a => Int -> a -> Vector a

cgenerate :: Dom Vector a => Int -> (Int -> a) -> Vector a

cgenerateM :: (Dom Vector a, Monad m) => Int -> (Int -> m a) -> m (Vector a)

cgenerateA :: (Dom Vector a, Applicative g) => Int -> (Int -> g a) -> g (Vector a)

cuncons :: Dom Vector a => Vector a -> Maybe (a, Vector a)

cunsnoc :: Dom Vector a => Vector a -> Maybe (Vector a, a)

creverse :: Dom Vector a => Vector a -> Vector a

cintersperse :: Dom Vector a => a -> Vector a -> Vector a

cnub :: (Dom Vector a, Eq a) => Vector a -> Vector a

cnubOrd :: (Dom Vector a, Ord a) => Vector a -> Vector a

csort :: (Dom Vector a, Ord a) => Vector a -> Vector a

csortBy :: Dom Vector a => (a -> a -> Ordering) -> Vector a -> Vector a

cinsert :: (Dom Vector a, Ord a) => a -> Vector a -> Vector a

cinsertBy :: Dom Vector a => (a -> a -> Ordering) -> a -> Vector a -> Vector a

ctakeWhile :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cdropWhile :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cspan :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

cbreak :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

cfilter :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cpartition :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

CFreeMonoid Vector

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom Vector a => [a] -> Vector a

ccons :: Dom Vector a => a -> Vector a -> Vector a

csnoc :: Dom Vector a => Vector a -> a -> Vector a

cfromListN :: Dom Vector a => Int -> [a] -> Vector a

ctake :: Dom Vector a => Int -> Vector a -> Vector a

cdrop :: Dom Vector a => Int -> Vector a -> Vector a

cinit :: Dom Vector a => Vector a -> Vector a

ctail :: Dom Vector a => Vector a -> Vector a

csplitAt :: Dom Vector a => Int -> Vector a -> (Vector a, Vector a)

creplicate :: Dom Vector a => Int -> a -> Vector a

cgenerate :: Dom Vector a => Int -> (Int -> a) -> Vector a

cgenerateM :: (Dom Vector a, Monad m) => Int -> (Int -> m a) -> m (Vector a)

cgenerateA :: (Dom Vector a, Applicative g) => Int -> (Int -> g a) -> g (Vector a)

cuncons :: Dom Vector a => Vector a -> Maybe (a, Vector a)

cunsnoc :: Dom Vector a => Vector a -> Maybe (Vector a, a)

creverse :: Dom Vector a => Vector a -> Vector a

cintersperse :: Dom Vector a => a -> Vector a -> Vector a

cnub :: (Dom Vector a, Eq a) => Vector a -> Vector a

cnubOrd :: (Dom Vector a, Ord a) => Vector a -> Vector a

csort :: (Dom Vector a, Ord a) => Vector a -> Vector a

csortBy :: Dom Vector a => (a -> a -> Ordering) -> Vector a -> Vector a

cinsert :: (Dom Vector a, Ord a) => a -> Vector a -> Vector a

cinsertBy :: Dom Vector a => (a -> a -> Ordering) -> a -> Vector a -> Vector a

ctakeWhile :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cdropWhile :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cspan :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

cbreak :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

cfilter :: Dom Vector a => (a -> Bool) -> Vector a -> Vector a

cpartition :: Dom Vector a => (a -> Bool) -> Vector a -> (Vector a, Vector a)

IsSequence mono => CFreeMonoid (WrapMono mono :: Type -> Type)

Defined in Control.Subcategory.Foldable

Methods

cbasicFromList :: Dom (WrapMono mono) a => [a] -> WrapMono mono a

ccons :: Dom (WrapMono mono) a => a -> WrapMono mono a -> WrapMono mono a

csnoc :: Dom (WrapMono mono) a => WrapMono mono a -> a -> WrapMono mono a

cfromListN :: Dom (WrapMono mono) a => Int -> [a] -> WrapMono mono a

ctake :: Dom (WrapMono mono) a => Int -> WrapMono mono a -> WrapMono mono a

cdrop :: Dom (WrapMono mono) a => Int -> WrapMono mono a -> WrapMono mono a

cinit :: Dom (WrapMono mono) a => WrapMono mono a -> WrapMono mono a

ctail :: Dom (WrapMono mono) a => WrapMono mono a -> WrapMono mono a

csplitAt :: Dom (WrapMono mono) a => Int -> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)

creplicate :: Dom (WrapMono mono) a => Int -> a -> WrapMono mono a

cgenerate :: Dom (WrapMono mono) a => Int -> (Int -> a) -> WrapMono mono a

cgenerateM :: (Dom (WrapMono mono) a, Monad m) => Int -> (Int -> m a) -> m (WrapMono mono a)

cgenerateA :: (Dom (WrapMono mono) a, Applicative g) => Int -> (Int -> g a) -> g (WrapMono mono a)

cuncons :: Dom (WrapMono mono) a => WrapMono mono a -> Maybe (a, WrapMono mono a)

cunsnoc :: Dom (WrapMono mono) a => WrapMono mono a -> Maybe (WrapMono mono a, a)

creverse :: Dom (WrapMono mono) a => WrapMono mono a -> WrapMono mono a

cintersperse :: Dom (WrapMono mono) a => a -> WrapMono mono a -> WrapMono mono a

cnub :: (Dom (WrapMono mono) a, Eq a) => WrapMono mono a -> WrapMono mono a

cnubOrd :: (Dom (WrapMono mono) a, Ord a) => WrapMono mono a -> WrapMono mono a

csort :: (Dom (WrapMono mono) a, Ord a) => WrapMono mono a -> WrapMono mono a

csortBy :: Dom (WrapMono mono) a => (a -> a -> Ordering) -> WrapMono mono a -> WrapMono mono a

cinsert :: (Dom (WrapMono mono) a, Ord a) => a -> WrapMono mono a -> WrapMono mono a

cinsertBy :: Dom (WrapMono mono) a => (a -> a -> Ordering) -> a -> WrapMono mono a -> WrapMono mono a

ctakeWhile :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> WrapMono mono a

cdropWhile :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> WrapMono mono a

cspan :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)

cbreak :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)

cfilter :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> WrapMono mono a

cpartition :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)

cfromList :: (CFreeMonoid f, Dom f a) => [a] -> f a

cfolded :: (CFoldable t, Dom t a) => forall f. (Contravariant f, Applicative f) => (a -> f a) -> t a -> f (t a)

Fold-optic for CFoldable instances. In the terminology of lens, cfolded is a constrained variant of folded optic.

   cfolded :: (CFoldable t, Dom t a) => Fold (t a) a
 

cfolding :: (CFoldable t, Dom t a, Contravariant f, Applicative f) => (s -> t a) -> (a -> f a) -> s -> f s

Lifts CFoldable along given function.

   cfolding :: (CFoldable t, Dom t a) => (s -> t a) -> Fold s a
 

cctraverseFreeMonoid :: (CFreeMonoid t, CApplicative f, CPointed f, Dom t a, Dom f (t b), Dom f b, Dom t b, Dom f (t b, t b)) => (a -> f b) -> t a -> f (t b)

cctraverseZipFreeMonoid :: (CFreeMonoid t, CRepeat f, Dom t a, Dom f (t b), Dom f b, Dom t b, Dom f (t b, t b)) => (a -> f b) -> t a -> f (t b)