Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- class Constrained f => CFoldable f where
- 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]
- ctoList :: (CFoldable f, Dom f a) => f a -> [a]
- class (CFunctor f, CFoldable f) => CTraversable f where
- ctraverse :: (Dom f a, Dom f b, Applicative g) => (a -> g b) -> f a -> g (f b)
- class (CFunctor f, forall x. Dom f x => Monoid (f x), CPointed f, CFoldable f) => CFreeMonoid f where
- 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
- 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)
- 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)
- cfolding :: (CFoldable t, Dom t a, Contravariant f, Applicative f) => (s -> t a) -> (a -> f a) -> s -> f s
- 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)
Documentation
class Constrained f => CFoldable f where Source #
cfoldMap :: (Dom f a, Monoid w) => (a -> w) -> f a -> w Source #
cfoldMap' :: (Dom f a, Monoid m) => (a -> m) -> f a -> m Source #
cfold :: (Dom f w, Monoid w) => f w -> w Source #
cfoldr :: Dom f a => (a -> b -> b) -> b -> f a -> b Source #
cfoldlM :: (Monad m, Dom f b) => (a -> b -> m a) -> a -> f b -> m a Source #
cfoldlM' :: (Monad m, Dom f b) => (a -> b -> m a) -> a -> f b -> m a Source #
cfoldrM :: (Monad m, Dom f a) => (a -> b -> m b) -> b -> f a -> m b Source #
cfoldrM' :: (Monad m, Dom f a) => (a -> b -> m b) -> b -> f a -> m b Source #
cfoldl :: Dom f a => (b -> a -> b) -> b -> f a -> b Source #
cfoldr' :: Dom f a => (a -> b -> b) -> b -> f a -> b Source #
cfoldl' :: Dom f a => (b -> a -> b) -> b -> f a -> b Source #
cbasicToList :: Dom f a => f a -> [a] Source #
cfoldr1 :: Dom f a => (a -> a -> a) -> f a -> a Source #
cfoldl1 :: Dom f a => (a -> a -> a) -> f a -> a Source #
cindex :: Dom f a => f a -> Int -> a Source #
cnull :: Dom f a => f a -> Bool Source #
clength :: Dom f a => f a -> Int Source #
cany :: Dom f a => (a -> Bool) -> f a -> Bool Source #
call :: Dom f a => (a -> Bool) -> f a -> Bool Source #
celem :: (Eq a, Dom f a) => a -> f a -> Bool Source #
cnotElem :: (Eq a, Dom f a) => a -> f a -> Bool Source #
cminimum :: (Ord a, Dom f a) => f a -> a Source #
cmaximum :: (Ord a, Dom f a) => f a -> a Source #
csum :: (Num a, Dom f a) => f a -> a Source #
cproduct :: (Num a, Dom f a) => f a -> a Source #
cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom f a, Dom g b) => (a -> g b) -> f a -> g () Source #
ctraverse_ :: (Applicative g, Dom f a) => (a -> g b) -> f a -> g () Source #
clast :: Dom f a => f a -> a Source #
chead :: Dom f a => f a -> a Source #
cfind :: Dom f a => (a -> Bool) -> f a -> Maybe a Source #
cfindIndex :: Dom f a => (a -> Bool) -> f a -> Maybe Int Source #
cfindIndices :: Dom f a => (a -> Bool) -> f a -> [Int] Source #
celemIndex :: (Dom f a, Eq a) => a -> f a -> Maybe Int Source #
celemIndices :: (Dom f a, Eq a) => a -> f a -> [Int] Source #
Instances
CFoldable [] Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom [] a, Monoid w) => (a -> w) -> [a] -> w Source # cfoldMap' :: (Dom [] a, Monoid m) => (a -> m) -> [a] -> m Source # cfold :: (Dom [] w, Monoid w) => [w] -> w Source # cfoldr :: Dom [] a => (a -> b -> b) -> b -> [a] -> b Source # cfoldlM :: (Monad m, Dom [] b) => (a -> b -> m a) -> a -> [b] -> m a Source # cfoldlM' :: (Monad m, Dom [] b) => (a -> b -> m a) -> a -> [b] -> m a Source # cfoldrM :: (Monad m, Dom [] a) => (a -> b -> m b) -> b -> [a] -> m b Source # cfoldrM' :: (Monad m, Dom [] a) => (a -> b -> m b) -> b -> [a] -> m b Source # cfoldl :: Dom [] a => (b -> a -> b) -> b -> [a] -> b Source # cfoldr' :: Dom [] a => (a -> b -> b) -> b -> [a] -> b Source # cfoldl' :: Dom [] a => (b -> a -> b) -> b -> [a] -> b Source # cbasicToList :: Dom [] a => [a] -> [a] Source # cfoldr1 :: Dom [] a => (a -> a -> a) -> [a] -> a Source # cfoldl1 :: Dom [] a => (a -> a -> a) -> [a] -> a Source # cindex :: Dom [] a => [a] -> Int -> a Source # cnull :: Dom [] a => [a] -> Bool Source # clength :: Dom [] a => [a] -> Int Source # cany :: Dom [] a => (a -> Bool) -> [a] -> Bool Source # call :: Dom [] a => (a -> Bool) -> [a] -> Bool Source # celem :: (Eq a, Dom [] a) => a -> [a] -> Bool Source # cnotElem :: (Eq a, Dom [] a) => a -> [a] -> Bool Source # cminimum :: (Ord a, Dom [] a) => [a] -> a Source # cmaximum :: (Ord a, Dom [] a) => [a] -> a Source # csum :: (Num a, Dom [] a) => [a] -> a Source # cproduct :: (Num a, Dom [] a) => [a] -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom [] a, Dom g b) => (a -> g b) -> [a] -> g () Source # ctraverse_ :: (Applicative g, Dom [] a) => (a -> g b) -> [a] -> g () Source # clast :: Dom [] a => [a] -> a Source # chead :: Dom [] a => [a] -> a Source # cfind :: Dom [] a => (a -> Bool) -> [a] -> Maybe a Source # cfindIndex :: Dom [] a => (a -> Bool) -> [a] -> Maybe Int Source # cfindIndices :: Dom [] a => (a -> Bool) -> [a] -> [Int] Source # celemIndex :: (Dom [] a, Eq a) => a -> [a] -> Maybe Int Source # celemIndices :: (Dom [] a, Eq a) => a -> [a] -> [Int] Source # | |
CFoldable Maybe Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Maybe a, Monoid w) => (a -> w) -> Maybe a -> w Source # cfoldMap' :: (Dom Maybe a, Monoid m) => (a -> m) -> Maybe a -> m Source # cfold :: (Dom Maybe w, Monoid w) => Maybe w -> w Source # cfoldr :: Dom Maybe a => (a -> b -> b) -> b -> Maybe a -> b Source # cfoldlM :: (Monad m, Dom Maybe b) => (a -> b -> m a) -> a -> Maybe b -> m a Source # cfoldlM' :: (Monad m, Dom Maybe b) => (a -> b -> m a) -> a -> Maybe b -> m a Source # cfoldrM :: (Monad m, Dom Maybe a) => (a -> b -> m b) -> b -> Maybe a -> m b Source # cfoldrM' :: (Monad m, Dom Maybe a) => (a -> b -> m b) -> b -> Maybe a -> m b Source # cfoldl :: Dom Maybe a => (b -> a -> b) -> b -> Maybe a -> b Source # cfoldr' :: Dom Maybe a => (a -> b -> b) -> b -> Maybe a -> b Source # cfoldl' :: Dom Maybe a => (b -> a -> b) -> b -> Maybe a -> b Source # cbasicToList :: Dom Maybe a => Maybe a -> [a] Source # cfoldr1 :: Dom Maybe a => (a -> a -> a) -> Maybe a -> a Source # cfoldl1 :: Dom Maybe a => (a -> a -> a) -> Maybe a -> a Source # cindex :: Dom Maybe a => Maybe a -> Int -> a Source # cnull :: Dom Maybe a => Maybe a -> Bool Source # clength :: Dom Maybe a => Maybe a -> Int Source # cany :: Dom Maybe a => (a -> Bool) -> Maybe a -> Bool Source # call :: Dom Maybe a => (a -> Bool) -> Maybe a -> Bool Source # celem :: (Eq a, Dom Maybe a) => a -> Maybe a -> Bool Source # cnotElem :: (Eq a, Dom Maybe a) => a -> Maybe a -> Bool Source # cminimum :: (Ord a, Dom Maybe a) => Maybe a -> a Source # cmaximum :: (Ord a, Dom Maybe a) => Maybe a -> a Source # csum :: (Num a, Dom Maybe a) => Maybe a -> a Source # cproduct :: (Num a, Dom Maybe a) => Maybe a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Maybe a, Dom g b) => (a -> g b) -> Maybe a -> g () Source # ctraverse_ :: (Applicative g, Dom Maybe a) => (a -> g b) -> Maybe a -> g () Source # clast :: Dom Maybe a => Maybe a -> a Source # chead :: Dom Maybe a => Maybe a -> a Source # cfind :: Dom Maybe a => (a -> Bool) -> Maybe a -> Maybe a Source # cfindIndex :: Dom Maybe a => (a -> Bool) -> Maybe a -> Maybe Int Source # cfindIndices :: Dom Maybe a => (a -> Bool) -> Maybe a -> [Int] Source # celemIndex :: (Dom Maybe a, Eq a) => a -> Maybe a -> Maybe Int Source # celemIndices :: (Dom Maybe a, Eq a) => a -> Maybe a -> [Int] Source # | |
CFoldable Par1 Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Par1 a, Monoid w) => (a -> w) -> Par1 a -> w Source # cfoldMap' :: (Dom Par1 a, Monoid m) => (a -> m) -> Par1 a -> m Source # cfold :: (Dom Par1 w, Monoid w) => Par1 w -> w Source # cfoldr :: Dom Par1 a => (a -> b -> b) -> b -> Par1 a -> b Source # cfoldlM :: (Monad m, Dom Par1 b) => (a -> b -> m a) -> a -> Par1 b -> m a Source # cfoldlM' :: (Monad m, Dom Par1 b) => (a -> b -> m a) -> a -> Par1 b -> m a Source # cfoldrM :: (Monad m, Dom Par1 a) => (a -> b -> m b) -> b -> Par1 a -> m b Source # cfoldrM' :: (Monad m, Dom Par1 a) => (a -> b -> m b) -> b -> Par1 a -> m b Source # cfoldl :: Dom Par1 a => (b -> a -> b) -> b -> Par1 a -> b Source # cfoldr' :: Dom Par1 a => (a -> b -> b) -> b -> Par1 a -> b Source # cfoldl' :: Dom Par1 a => (b -> a -> b) -> b -> Par1 a -> b Source # cbasicToList :: Dom Par1 a => Par1 a -> [a] Source # cfoldr1 :: Dom Par1 a => (a -> a -> a) -> Par1 a -> a Source # cfoldl1 :: Dom Par1 a => (a -> a -> a) -> Par1 a -> a Source # cindex :: Dom Par1 a => Par1 a -> Int -> a Source # cnull :: Dom Par1 a => Par1 a -> Bool Source # clength :: Dom Par1 a => Par1 a -> Int Source # cany :: Dom Par1 a => (a -> Bool) -> Par1 a -> Bool Source # call :: Dom Par1 a => (a -> Bool) -> Par1 a -> Bool Source # celem :: (Eq a, Dom Par1 a) => a -> Par1 a -> Bool Source # cnotElem :: (Eq a, Dom Par1 a) => a -> Par1 a -> Bool Source # cminimum :: (Ord a, Dom Par1 a) => Par1 a -> a Source # cmaximum :: (Ord a, Dom Par1 a) => Par1 a -> a Source # csum :: (Num a, Dom Par1 a) => Par1 a -> a Source # cproduct :: (Num a, Dom Par1 a) => Par1 a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Par1 a, Dom g b) => (a -> g b) -> Par1 a -> g () Source # ctraverse_ :: (Applicative g, Dom Par1 a) => (a -> g b) -> Par1 a -> g () Source # clast :: Dom Par1 a => Par1 a -> a Source # chead :: Dom Par1 a => Par1 a -> a Source # cfind :: Dom Par1 a => (a -> Bool) -> Par1 a -> Maybe a Source # cfindIndex :: Dom Par1 a => (a -> Bool) -> Par1 a -> Maybe Int Source # cfindIndices :: Dom Par1 a => (a -> Bool) -> Par1 a -> [Int] Source # celemIndex :: (Dom Par1 a, Eq a) => a -> Par1 a -> Maybe Int Source # celemIndices :: (Dom Par1 a, Eq a) => a -> Par1 a -> [Int] Source # | |
CFoldable Complex Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Complex a, Monoid w) => (a -> w) -> Complex a -> w Source # cfoldMap' :: (Dom Complex a, Monoid m) => (a -> m) -> Complex a -> m Source # cfold :: (Dom Complex w, Monoid w) => Complex w -> w Source # cfoldr :: Dom Complex a => (a -> b -> b) -> b -> Complex a -> b Source # cfoldlM :: (Monad m, Dom Complex b) => (a -> b -> m a) -> a -> Complex b -> m a Source # cfoldlM' :: (Monad m, Dom Complex b) => (a -> b -> m a) -> a -> Complex b -> m a Source # cfoldrM :: (Monad m, Dom Complex a) => (a -> b -> m b) -> b -> Complex a -> m b Source # cfoldrM' :: (Monad m, Dom Complex a) => (a -> b -> m b) -> b -> Complex a -> m b Source # cfoldl :: Dom Complex a => (b -> a -> b) -> b -> Complex a -> b Source # cfoldr' :: Dom Complex a => (a -> b -> b) -> b -> Complex a -> b Source # cfoldl' :: Dom Complex a => (b -> a -> b) -> b -> Complex a -> b Source # cbasicToList :: Dom Complex a => Complex a -> [a] Source # cfoldr1 :: Dom Complex a => (a -> a -> a) -> Complex a -> a Source # cfoldl1 :: Dom Complex a => (a -> a -> a) -> Complex a -> a Source # cindex :: Dom Complex a => Complex a -> Int -> a Source # cnull :: Dom Complex a => Complex a -> Bool Source # clength :: Dom Complex a => Complex a -> Int Source # cany :: Dom Complex a => (a -> Bool) -> Complex a -> Bool Source # call :: Dom Complex a => (a -> Bool) -> Complex a -> Bool Source # celem :: (Eq a, Dom Complex a) => a -> Complex a -> Bool Source # cnotElem :: (Eq a, Dom Complex a) => a -> Complex a -> Bool Source # cminimum :: (Ord a, Dom Complex a) => Complex a -> a Source # cmaximum :: (Ord a, Dom Complex a) => Complex a -> a Source # csum :: (Num a, Dom Complex a) => Complex a -> a Source # cproduct :: (Num a, Dom Complex a) => Complex a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Complex a, Dom g b) => (a -> g b) -> Complex a -> g () Source # ctraverse_ :: (Applicative g, Dom Complex a) => (a -> g b) -> Complex a -> g () Source # clast :: Dom Complex a => Complex a -> a Source # chead :: Dom Complex a => Complex a -> a Source # cfind :: Dom Complex a => (a -> Bool) -> Complex a -> Maybe a Source # cfindIndex :: Dom Complex a => (a -> Bool) -> Complex a -> Maybe Int Source # cfindIndices :: Dom Complex a => (a -> Bool) -> Complex a -> [Int] Source # celemIndex :: (Dom Complex a, Eq a) => a -> Complex a -> Maybe Int Source # celemIndices :: (Dom Complex a, Eq a) => a -> Complex a -> [Int] Source # | |
CFoldable Min Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Min a, Monoid w) => (a -> w) -> Min a -> w Source # cfoldMap' :: (Dom Min a, Monoid m) => (a -> m) -> Min a -> m Source # cfold :: (Dom Min w, Monoid w) => Min w -> w Source # cfoldr :: Dom Min a => (a -> b -> b) -> b -> Min a -> b Source # cfoldlM :: (Monad m, Dom Min b) => (a -> b -> m a) -> a -> Min b -> m a Source # cfoldlM' :: (Monad m, Dom Min b) => (a -> b -> m a) -> a -> Min b -> m a Source # cfoldrM :: (Monad m, Dom Min a) => (a -> b -> m b) -> b -> Min a -> m b Source # cfoldrM' :: (Monad m, Dom Min a) => (a -> b -> m b) -> b -> Min a -> m b Source # cfoldl :: Dom Min a => (b -> a -> b) -> b -> Min a -> b Source # cfoldr' :: Dom Min a => (a -> b -> b) -> b -> Min a -> b Source # cfoldl' :: Dom Min a => (b -> a -> b) -> b -> Min a -> b Source # cbasicToList :: Dom Min a => Min a -> [a] Source # cfoldr1 :: Dom Min a => (a -> a -> a) -> Min a -> a Source # cfoldl1 :: Dom Min a => (a -> a -> a) -> Min a -> a Source # cindex :: Dom Min a => Min a -> Int -> a Source # cnull :: Dom Min a => Min a -> Bool Source # clength :: Dom Min a => Min a -> Int Source # cany :: Dom Min a => (a -> Bool) -> Min a -> Bool Source # call :: Dom Min a => (a -> Bool) -> Min a -> Bool Source # celem :: (Eq a, Dom Min a) => a -> Min a -> Bool Source # cnotElem :: (Eq a, Dom Min a) => a -> Min a -> Bool Source # cminimum :: (Ord a, Dom Min a) => Min a -> a Source # cmaximum :: (Ord a, Dom Min a) => Min a -> a Source # csum :: (Num a, Dom Min a) => Min a -> a Source # cproduct :: (Num a, Dom Min a) => Min a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Min a, Dom g b) => (a -> g b) -> Min a -> g () Source # ctraverse_ :: (Applicative g, Dom Min a) => (a -> g b) -> Min a -> g () Source # clast :: Dom Min a => Min a -> a Source # chead :: Dom Min a => Min a -> a Source # cfind :: Dom Min a => (a -> Bool) -> Min a -> Maybe a Source # cfindIndex :: Dom Min a => (a -> Bool) -> Min a -> Maybe Int Source # cfindIndices :: Dom Min a => (a -> Bool) -> Min a -> [Int] Source # celemIndex :: (Dom Min a, Eq a) => a -> Min a -> Maybe Int Source # celemIndices :: (Dom Min a, Eq a) => a -> Min a -> [Int] Source # | |
CFoldable Max Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Max a, Monoid w) => (a -> w) -> Max a -> w Source # cfoldMap' :: (Dom Max a, Monoid m) => (a -> m) -> Max a -> m Source # cfold :: (Dom Max w, Monoid w) => Max w -> w Source # cfoldr :: Dom Max a => (a -> b -> b) -> b -> Max a -> b Source # cfoldlM :: (Monad m, Dom Max b) => (a -> b -> m a) -> a -> Max b -> m a Source # cfoldlM' :: (Monad m, Dom Max b) => (a -> b -> m a) -> a -> Max b -> m a Source # cfoldrM :: (Monad m, Dom Max a) => (a -> b -> m b) -> b -> Max a -> m b Source # cfoldrM' :: (Monad m, Dom Max a) => (a -> b -> m b) -> b -> Max a -> m b Source # cfoldl :: Dom Max a => (b -> a -> b) -> b -> Max a -> b Source # cfoldr' :: Dom Max a => (a -> b -> b) -> b -> Max a -> b Source # cfoldl' :: Dom Max a => (b -> a -> b) -> b -> Max a -> b Source # cbasicToList :: Dom Max a => Max a -> [a] Source # cfoldr1 :: Dom Max a => (a -> a -> a) -> Max a -> a Source # cfoldl1 :: Dom Max a => (a -> a -> a) -> Max a -> a Source # cindex :: Dom Max a => Max a -> Int -> a Source # cnull :: Dom Max a => Max a -> Bool Source # clength :: Dom Max a => Max a -> Int Source # cany :: Dom Max a => (a -> Bool) -> Max a -> Bool Source # call :: Dom Max a => (a -> Bool) -> Max a -> Bool Source # celem :: (Eq a, Dom Max a) => a -> Max a -> Bool Source # cnotElem :: (Eq a, Dom Max a) => a -> Max a -> Bool Source # cminimum :: (Ord a, Dom Max a) => Max a -> a Source # cmaximum :: (Ord a, Dom Max a) => Max a -> a Source # csum :: (Num a, Dom Max a) => Max a -> a Source # cproduct :: (Num a, Dom Max a) => Max a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Max a, Dom g b) => (a -> g b) -> Max a -> g () Source # ctraverse_ :: (Applicative g, Dom Max a) => (a -> g b) -> Max a -> g () Source # clast :: Dom Max a => Max a -> a Source # chead :: Dom Max a => Max a -> a Source # cfind :: Dom Max a => (a -> Bool) -> Max a -> Maybe a Source # cfindIndex :: Dom Max a => (a -> Bool) -> Max a -> Maybe Int Source # cfindIndices :: Dom Max a => (a -> Bool) -> Max a -> [Int] Source # celemIndex :: (Dom Max a, Eq a) => a -> Max a -> Maybe Int Source # celemIndices :: (Dom Max a, Eq a) => a -> Max a -> [Int] Source # | |
CFoldable First Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom First a, Monoid w) => (a -> w) -> First a -> w Source # cfoldMap' :: (Dom First a, Monoid m) => (a -> m) -> First a -> m Source # cfold :: (Dom First w, Monoid w) => First w -> w Source # cfoldr :: Dom First a => (a -> b -> b) -> b -> First a -> b Source # cfoldlM :: (Monad m, Dom First b) => (a -> b -> m a) -> a -> First b -> m a Source # cfoldlM' :: (Monad m, Dom First b) => (a -> b -> m a) -> a -> First b -> m a Source # cfoldrM :: (Monad m, Dom First a) => (a -> b -> m b) -> b -> First a -> m b Source # cfoldrM' :: (Monad m, Dom First a) => (a -> b -> m b) -> b -> First a -> m b Source # cfoldl :: Dom First a => (b -> a -> b) -> b -> First a -> b Source # cfoldr' :: Dom First a => (a -> b -> b) -> b -> First a -> b Source # cfoldl' :: Dom First a => (b -> a -> b) -> b -> First a -> b Source # cbasicToList :: Dom First a => First a -> [a] Source # cfoldr1 :: Dom First a => (a -> a -> a) -> First a -> a Source # cfoldl1 :: Dom First a => (a -> a -> a) -> First a -> a Source # cindex :: Dom First a => First a -> Int -> a Source # cnull :: Dom First a => First a -> Bool Source # clength :: Dom First a => First a -> Int Source # cany :: Dom First a => (a -> Bool) -> First a -> Bool Source # call :: Dom First a => (a -> Bool) -> First a -> Bool Source # celem :: (Eq a, Dom First a) => a -> First a -> Bool Source # cnotElem :: (Eq a, Dom First a) => a -> First a -> Bool Source # cminimum :: (Ord a, Dom First a) => First a -> a Source # cmaximum :: (Ord a, Dom First a) => First a -> a Source # csum :: (Num a, Dom First a) => First a -> a Source # cproduct :: (Num a, Dom First a) => First a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom First a, Dom g b) => (a -> g b) -> First a -> g () Source # ctraverse_ :: (Applicative g, Dom First a) => (a -> g b) -> First a -> g () Source # clast :: Dom First a => First a -> a Source # chead :: Dom First a => First a -> a Source # cfind :: Dom First a => (a -> Bool) -> First a -> Maybe a Source # cfindIndex :: Dom First a => (a -> Bool) -> First a -> Maybe Int Source # cfindIndices :: Dom First a => (a -> Bool) -> First a -> [Int] Source # celemIndex :: (Dom First a, Eq a) => a -> First a -> Maybe Int Source # celemIndices :: (Dom First a, Eq a) => a -> First a -> [Int] Source # | |
CFoldable Last Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Last a, Monoid w) => (a -> w) -> Last a -> w Source # cfoldMap' :: (Dom Last a, Monoid m) => (a -> m) -> Last a -> m Source # cfold :: (Dom Last w, Monoid w) => Last w -> w Source # cfoldr :: Dom Last a => (a -> b -> b) -> b -> Last a -> b Source # cfoldlM :: (Monad m, Dom Last b) => (a -> b -> m a) -> a -> Last b -> m a Source # cfoldlM' :: (Monad m, Dom Last b) => (a -> b -> m a) -> a -> Last b -> m a Source # cfoldrM :: (Monad m, Dom Last a) => (a -> b -> m b) -> b -> Last a -> m b Source # cfoldrM' :: (Monad m, Dom Last a) => (a -> b -> m b) -> b -> Last a -> m b Source # cfoldl :: Dom Last a => (b -> a -> b) -> b -> Last a -> b Source # cfoldr' :: Dom Last a => (a -> b -> b) -> b -> Last a -> b Source # cfoldl' :: Dom Last a => (b -> a -> b) -> b -> Last a -> b Source # cbasicToList :: Dom Last a => Last a -> [a] Source # cfoldr1 :: Dom Last a => (a -> a -> a) -> Last a -> a Source # cfoldl1 :: Dom Last a => (a -> a -> a) -> Last a -> a Source # cindex :: Dom Last a => Last a -> Int -> a Source # cnull :: Dom Last a => Last a -> Bool Source # clength :: Dom Last a => Last a -> Int Source # cany :: Dom Last a => (a -> Bool) -> Last a -> Bool Source # call :: Dom Last a => (a -> Bool) -> Last a -> Bool Source # celem :: (Eq a, Dom Last a) => a -> Last a -> Bool Source # cnotElem :: (Eq a, Dom Last a) => a -> Last a -> Bool Source # cminimum :: (Ord a, Dom Last a) => Last a -> a Source # cmaximum :: (Ord a, Dom Last a) => Last a -> a Source # csum :: (Num a, Dom Last a) => Last a -> a Source # cproduct :: (Num a, Dom Last a) => Last a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Last a, Dom g b) => (a -> g b) -> Last a -> g () Source # ctraverse_ :: (Applicative g, Dom Last a) => (a -> g b) -> Last a -> g () Source # clast :: Dom Last a => Last a -> a Source # chead :: Dom Last a => Last a -> a Source # cfind :: Dom Last a => (a -> Bool) -> Last a -> Maybe a Source # cfindIndex :: Dom Last a => (a -> Bool) -> Last a -> Maybe Int Source # cfindIndices :: Dom Last a => (a -> Bool) -> Last a -> [Int] Source # celemIndex :: (Dom Last a, Eq a) => a -> Last a -> Maybe Int Source # celemIndices :: (Dom Last a, Eq a) => a -> Last a -> [Int] Source # | |
CFoldable Option Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Option a, Monoid w) => (a -> w) -> Option a -> w Source # cfoldMap' :: (Dom Option a, Monoid m) => (a -> m) -> Option a -> m Source # cfold :: (Dom Option w, Monoid w) => Option w -> w Source # cfoldr :: Dom Option a => (a -> b -> b) -> b -> Option a -> b Source # cfoldlM :: (Monad m, Dom Option b) => (a -> b -> m a) -> a -> Option b -> m a Source # cfoldlM' :: (Monad m, Dom Option b) => (a -> b -> m a) -> a -> Option b -> m a Source # cfoldrM :: (Monad m, Dom Option a) => (a -> b -> m b) -> b -> Option a -> m b Source # cfoldrM' :: (Monad m, Dom Option a) => (a -> b -> m b) -> b -> Option a -> m b Source # cfoldl :: Dom Option a => (b -> a -> b) -> b -> Option a -> b Source # cfoldr' :: Dom Option a => (a -> b -> b) -> b -> Option a -> b Source # cfoldl' :: Dom Option a => (b -> a -> b) -> b -> Option a -> b Source # cbasicToList :: Dom Option a => Option a -> [a] Source # cfoldr1 :: Dom Option a => (a -> a -> a) -> Option a -> a Source # cfoldl1 :: Dom Option a => (a -> a -> a) -> Option a -> a Source # cindex :: Dom Option a => Option a -> Int -> a Source # cnull :: Dom Option a => Option a -> Bool Source # clength :: Dom Option a => Option a -> Int Source # cany :: Dom Option a => (a -> Bool) -> Option a -> Bool Source # call :: Dom Option a => (a -> Bool) -> Option a -> Bool Source # celem :: (Eq a, Dom Option a) => a -> Option a -> Bool Source # cnotElem :: (Eq a, Dom Option a) => a -> Option a -> Bool Source # cminimum :: (Ord a, Dom Option a) => Option a -> a Source # cmaximum :: (Ord a, Dom Option a) => Option a -> a Source # csum :: (Num a, Dom Option a) => Option a -> a Source # cproduct :: (Num a, Dom Option a) => Option a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Option a, Dom g b) => (a -> g b) -> Option a -> g () Source # ctraverse_ :: (Applicative g, Dom Option a) => (a -> g b) -> Option a -> g () Source # clast :: Dom Option a => Option a -> a Source # chead :: Dom Option a => Option a -> a Source # cfind :: Dom Option a => (a -> Bool) -> Option a -> Maybe a Source # cfindIndex :: Dom Option a => (a -> Bool) -> Option a -> Maybe Int Source # cfindIndices :: Dom Option a => (a -> Bool) -> Option a -> [Int] Source # celemIndex :: (Dom Option a, Eq a) => a -> Option a -> Maybe Int Source # celemIndices :: (Dom Option a, Eq a) => a -> Option a -> [Int] Source # | |
CFoldable ZipList Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom ZipList a, Monoid w) => (a -> w) -> ZipList a -> w Source # cfoldMap' :: (Dom ZipList a, Monoid m) => (a -> m) -> ZipList a -> m Source # cfold :: (Dom ZipList w, Monoid w) => ZipList w -> w Source # cfoldr :: Dom ZipList a => (a -> b -> b) -> b -> ZipList a -> b Source # cfoldlM :: (Monad m, Dom ZipList b) => (a -> b -> m a) -> a -> ZipList b -> m a Source # cfoldlM' :: (Monad m, Dom ZipList b) => (a -> b -> m a) -> a -> ZipList b -> m a Source # cfoldrM :: (Monad m, Dom ZipList a) => (a -> b -> m b) -> b -> ZipList a -> m b Source # cfoldrM' :: (Monad m, Dom ZipList a) => (a -> b -> m b) -> b -> ZipList a -> m b Source # cfoldl :: Dom ZipList a => (b -> a -> b) -> b -> ZipList a -> b Source # cfoldr' :: Dom ZipList a => (a -> b -> b) -> b -> ZipList a -> b Source # cfoldl' :: Dom ZipList a => (b -> a -> b) -> b -> ZipList a -> b Source # cbasicToList :: Dom ZipList a => ZipList a -> [a] Source # cfoldr1 :: Dom ZipList a => (a -> a -> a) -> ZipList a -> a Source # cfoldl1 :: Dom ZipList a => (a -> a -> a) -> ZipList a -> a Source # cindex :: Dom ZipList a => ZipList a -> Int -> a Source # cnull :: Dom ZipList a => ZipList a -> Bool Source # clength :: Dom ZipList a => ZipList a -> Int Source # cany :: Dom ZipList a => (a -> Bool) -> ZipList a -> Bool Source # call :: Dom ZipList a => (a -> Bool) -> ZipList a -> Bool Source # celem :: (Eq a, Dom ZipList a) => a -> ZipList a -> Bool Source # cnotElem :: (Eq a, Dom ZipList a) => a -> ZipList a -> Bool Source # cminimum :: (Ord a, Dom ZipList a) => ZipList a -> a Source # cmaximum :: (Ord a, Dom ZipList a) => ZipList a -> a Source # csum :: (Num a, Dom ZipList a) => ZipList a -> a Source # cproduct :: (Num a, Dom ZipList a) => ZipList a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom ZipList a, Dom g b) => (a -> g b) -> ZipList a -> g () Source # ctraverse_ :: (Applicative g, Dom ZipList a) => (a -> g b) -> ZipList a -> g () Source # clast :: Dom ZipList a => ZipList a -> a Source # chead :: Dom ZipList a => ZipList a -> a Source # cfind :: Dom ZipList a => (a -> Bool) -> ZipList a -> Maybe a Source # cfindIndex :: Dom ZipList a => (a -> Bool) -> ZipList a -> Maybe Int Source # cfindIndices :: Dom ZipList a => (a -> Bool) -> ZipList a -> [Int] Source # celemIndex :: (Dom ZipList a, Eq a) => a -> ZipList a -> Maybe Int Source # celemIndices :: (Dom ZipList a, Eq a) => a -> ZipList a -> [Int] Source # | |
CFoldable Identity Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Identity a, Monoid w) => (a -> w) -> Identity a -> w Source # cfoldMap' :: (Dom Identity a, Monoid m) => (a -> m) -> Identity a -> m Source # cfold :: (Dom Identity w, Monoid w) => Identity w -> w Source # cfoldr :: Dom Identity a => (a -> b -> b) -> b -> Identity a -> b Source # cfoldlM :: (Monad m, Dom Identity b) => (a -> b -> m a) -> a -> Identity b -> m a Source # cfoldlM' :: (Monad m, Dom Identity b) => (a -> b -> m a) -> a -> Identity b -> m a Source # cfoldrM :: (Monad m, Dom Identity a) => (a -> b -> m b) -> b -> Identity a -> m b Source # cfoldrM' :: (Monad m, Dom Identity a) => (a -> b -> m b) -> b -> Identity a -> m b Source # cfoldl :: Dom Identity a => (b -> a -> b) -> b -> Identity a -> b Source # cfoldr' :: Dom Identity a => (a -> b -> b) -> b -> Identity a -> b Source # cfoldl' :: Dom Identity a => (b -> a -> b) -> b -> Identity a -> b Source # cbasicToList :: Dom Identity a => Identity a -> [a] Source # cfoldr1 :: Dom Identity a => (a -> a -> a) -> Identity a -> a Source # cfoldl1 :: Dom Identity a => (a -> a -> a) -> Identity a -> a Source # cindex :: Dom Identity a => Identity a -> Int -> a Source # cnull :: Dom Identity a => Identity a -> Bool Source # clength :: Dom Identity a => Identity a -> Int Source # cany :: Dom Identity a => (a -> Bool) -> Identity a -> Bool Source # call :: Dom Identity a => (a -> Bool) -> Identity a -> Bool Source # celem :: (Eq a, Dom Identity a) => a -> Identity a -> Bool Source # cnotElem :: (Eq a, Dom Identity a) => a -> Identity a -> Bool Source # cminimum :: (Ord a, Dom Identity a) => Identity a -> a Source # cmaximum :: (Ord a, Dom Identity a) => Identity a -> a Source # csum :: (Num a, Dom Identity a) => Identity a -> a Source # cproduct :: (Num a, Dom Identity a) => Identity a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Identity a, Dom g b) => (a -> g b) -> Identity a -> g () Source # ctraverse_ :: (Applicative g, Dom Identity a) => (a -> g b) -> Identity a -> g () Source # clast :: Dom Identity a => Identity a -> a Source # chead :: Dom Identity a => Identity a -> a Source # cfind :: Dom Identity a => (a -> Bool) -> Identity a -> Maybe a Source # cfindIndex :: Dom Identity a => (a -> Bool) -> Identity a -> Maybe Int Source # cfindIndices :: Dom Identity a => (a -> Bool) -> Identity a -> [Int] Source # celemIndex :: (Dom Identity a, Eq a) => a -> Identity a -> Maybe Int Source # celemIndices :: (Dom Identity a, Eq a) => a -> Identity a -> [Int] Source # | |
CFoldable First Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom First a, Monoid w) => (a -> w) -> First a -> w Source # cfoldMap' :: (Dom First a, Monoid m) => (a -> m) -> First a -> m Source # cfold :: (Dom First w, Monoid w) => First w -> w Source # cfoldr :: Dom First a => (a -> b -> b) -> b -> First a -> b Source # cfoldlM :: (Monad m, Dom First b) => (a -> b -> m a) -> a -> First b -> m a Source # cfoldlM' :: (Monad m, Dom First b) => (a -> b -> m a) -> a -> First b -> m a Source # cfoldrM :: (Monad m, Dom First a) => (a -> b -> m b) -> b -> First a -> m b Source # cfoldrM' :: (Monad m, Dom First a) => (a -> b -> m b) -> b -> First a -> m b Source # cfoldl :: Dom First a => (b -> a -> b) -> b -> First a -> b Source # cfoldr' :: Dom First a => (a -> b -> b) -> b -> First a -> b Source # cfoldl' :: Dom First a => (b -> a -> b) -> b -> First a -> b Source # cbasicToList :: Dom First a => First a -> [a] Source # cfoldr1 :: Dom First a => (a -> a -> a) -> First a -> a Source # cfoldl1 :: Dom First a => (a -> a -> a) -> First a -> a Source # cindex :: Dom First a => First a -> Int -> a Source # cnull :: Dom First a => First a -> Bool Source # clength :: Dom First a => First a -> Int Source # cany :: Dom First a => (a -> Bool) -> First a -> Bool Source # call :: Dom First a => (a -> Bool) -> First a -> Bool Source # celem :: (Eq a, Dom First a) => a -> First a -> Bool Source # cnotElem :: (Eq a, Dom First a) => a -> First a -> Bool Source # cminimum :: (Ord a, Dom First a) => First a -> a Source # cmaximum :: (Ord a, Dom First a) => First a -> a Source # csum :: (Num a, Dom First a) => First a -> a Source # cproduct :: (Num a, Dom First a) => First a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom First a, Dom g b) => (a -> g b) -> First a -> g () Source # ctraverse_ :: (Applicative g, Dom First a) => (a -> g b) -> First a -> g () Source # clast :: Dom First a => First a -> a Source # chead :: Dom First a => First a -> a Source # cfind :: Dom First a => (a -> Bool) -> First a -> Maybe a Source # cfindIndex :: Dom First a => (a -> Bool) -> First a -> Maybe Int Source # cfindIndices :: Dom First a => (a -> Bool) -> First a -> [Int] Source # celemIndex :: (Dom First a, Eq a) => a -> First a -> Maybe Int Source # celemIndices :: (Dom First a, Eq a) => a -> First a -> [Int] Source # | |
CFoldable Last Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Last a, Monoid w) => (a -> w) -> Last a -> w Source # cfoldMap' :: (Dom Last a, Monoid m) => (a -> m) -> Last a -> m Source # cfold :: (Dom Last w, Monoid w) => Last w -> w Source # cfoldr :: Dom Last a => (a -> b -> b) -> b -> Last a -> b Source # cfoldlM :: (Monad m, Dom Last b) => (a -> b -> m a) -> a -> Last b -> m a Source # cfoldlM' :: (Monad m, Dom Last b) => (a -> b -> m a) -> a -> Last b -> m a Source # cfoldrM :: (Monad m, Dom Last a) => (a -> b -> m b) -> b -> Last a -> m b Source # cfoldrM' :: (Monad m, Dom Last a) => (a -> b -> m b) -> b -> Last a -> m b Source # cfoldl :: Dom Last a => (b -> a -> b) -> b -> Last a -> b Source # cfoldr' :: Dom Last a => (a -> b -> b) -> b -> Last a -> b Source # cfoldl' :: Dom Last a => (b -> a -> b) -> b -> Last a -> b Source # cbasicToList :: Dom Last a => Last a -> [a] Source # cfoldr1 :: Dom Last a => (a -> a -> a) -> Last a -> a Source # cfoldl1 :: Dom Last a => (a -> a -> a) -> Last a -> a Source # cindex :: Dom Last a => Last a -> Int -> a Source # cnull :: Dom Last a => Last a -> Bool Source # clength :: Dom Last a => Last a -> Int Source # cany :: Dom Last a => (a -> Bool) -> Last a -> Bool Source # call :: Dom Last a => (a -> Bool) -> Last a -> Bool Source # celem :: (Eq a, Dom Last a) => a -> Last a -> Bool Source # cnotElem :: (Eq a, Dom Last a) => a -> Last a -> Bool Source # cminimum :: (Ord a, Dom Last a) => Last a -> a Source # cmaximum :: (Ord a, Dom Last a) => Last a -> a Source # csum :: (Num a, Dom Last a) => Last a -> a Source # cproduct :: (Num a, Dom Last a) => Last a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Last a, Dom g b) => (a -> g b) -> Last a -> g () Source # ctraverse_ :: (Applicative g, Dom Last a) => (a -> g b) -> Last a -> g () Source # clast :: Dom Last a => Last a -> a Source # chead :: Dom Last a => Last a -> a Source # cfind :: Dom Last a => (a -> Bool) -> Last a -> Maybe a Source # cfindIndex :: Dom Last a => (a -> Bool) -> Last a -> Maybe Int Source # cfindIndices :: Dom Last a => (a -> Bool) -> Last a -> [Int] Source # celemIndex :: (Dom Last a, Eq a) => a -> Last a -> Maybe Int Source # celemIndices :: (Dom Last a, Eq a) => a -> Last a -> [Int] Source # | |
CFoldable Down Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Down a, Monoid w) => (a -> w) -> Down a -> w Source # cfoldMap' :: (Dom Down a, Monoid m) => (a -> m) -> Down a -> m Source # cfold :: (Dom Down w, Monoid w) => Down w -> w Source # cfoldr :: Dom Down a => (a -> b -> b) -> b -> Down a -> b Source # cfoldlM :: (Monad m, Dom Down b) => (a -> b -> m a) -> a -> Down b -> m a Source # cfoldlM' :: (Monad m, Dom Down b) => (a -> b -> m a) -> a -> Down b -> m a Source # cfoldrM :: (Monad m, Dom Down a) => (a -> b -> m b) -> b -> Down a -> m b Source # cfoldrM' :: (Monad m, Dom Down a) => (a -> b -> m b) -> b -> Down a -> m b Source # cfoldl :: Dom Down a => (b -> a -> b) -> b -> Down a -> b Source # cfoldr' :: Dom Down a => (a -> b -> b) -> b -> Down a -> b Source # cfoldl' :: Dom Down a => (b -> a -> b) -> b -> Down a -> b Source # cbasicToList :: Dom Down a => Down a -> [a] Source # cfoldr1 :: Dom Down a => (a -> a -> a) -> Down a -> a Source # cfoldl1 :: Dom Down a => (a -> a -> a) -> Down a -> a Source # cindex :: Dom Down a => Down a -> Int -> a Source # cnull :: Dom Down a => Down a -> Bool Source # clength :: Dom Down a => Down a -> Int Source # cany :: Dom Down a => (a -> Bool) -> Down a -> Bool Source # call :: Dom Down a => (a -> Bool) -> Down a -> Bool Source # celem :: (Eq a, Dom Down a) => a -> Down a -> Bool Source # cnotElem :: (Eq a, Dom Down a) => a -> Down a -> Bool Source # cminimum :: (Ord a, Dom Down a) => Down a -> a Source # cmaximum :: (Ord a, Dom Down a) => Down a -> a Source # csum :: (Num a, Dom Down a) => Down a -> a Source # cproduct :: (Num a, Dom Down a) => Down a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Down a, Dom g b) => (a -> g b) -> Down a -> g () Source # ctraverse_ :: (Applicative g, Dom Down a) => (a -> g b) -> Down a -> g () Source # clast :: Dom Down a => Down a -> a Source # chead :: Dom Down a => Down a -> a Source # cfind :: Dom Down a => (a -> Bool) -> Down a -> Maybe a Source # cfindIndex :: Dom Down a => (a -> Bool) -> Down a -> Maybe Int Source # cfindIndices :: Dom Down a => (a -> Bool) -> Down a -> [Int] Source # celemIndex :: (Dom Down a, Eq a) => a -> Down a -> Maybe Int Source # celemIndices :: (Dom Down a, Eq a) => a -> Down a -> [Int] Source # | |
CFoldable NonEmpty Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom NonEmpty a, Monoid w) => (a -> w) -> NonEmpty a -> w Source # cfoldMap' :: (Dom NonEmpty a, Monoid m) => (a -> m) -> NonEmpty a -> m Source # cfold :: (Dom NonEmpty w, Monoid w) => NonEmpty w -> w Source # cfoldr :: Dom NonEmpty a => (a -> b -> b) -> b -> NonEmpty a -> b Source # cfoldlM :: (Monad m, Dom NonEmpty b) => (a -> b -> m a) -> a -> NonEmpty b -> m a Source # cfoldlM' :: (Monad m, Dom NonEmpty b) => (a -> b -> m a) -> a -> NonEmpty b -> m a Source # cfoldrM :: (Monad m, Dom NonEmpty a) => (a -> b -> m b) -> b -> NonEmpty a -> m b Source # cfoldrM' :: (Monad m, Dom NonEmpty a) => (a -> b -> m b) -> b -> NonEmpty a -> m b Source # cfoldl :: Dom NonEmpty a => (b -> a -> b) -> b -> NonEmpty a -> b Source # cfoldr' :: Dom NonEmpty a => (a -> b -> b) -> b -> NonEmpty a -> b Source # cfoldl' :: Dom NonEmpty a => (b -> a -> b) -> b -> NonEmpty a -> b Source # cbasicToList :: Dom NonEmpty a => NonEmpty a -> [a] Source # cfoldr1 :: Dom NonEmpty a => (a -> a -> a) -> NonEmpty a -> a Source # cfoldl1 :: Dom NonEmpty a => (a -> a -> a) -> NonEmpty a -> a Source # cindex :: Dom NonEmpty a => NonEmpty a -> Int -> a Source # cnull :: Dom NonEmpty a => NonEmpty a -> Bool Source # clength :: Dom NonEmpty a => NonEmpty a -> Int Source # cany :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> Bool Source # call :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> Bool Source # celem :: (Eq a, Dom NonEmpty a) => a -> NonEmpty a -> Bool Source # cnotElem :: (Eq a, Dom NonEmpty a) => a -> NonEmpty a -> Bool Source # cminimum :: (Ord a, Dom NonEmpty a) => NonEmpty a -> a Source # cmaximum :: (Ord a, Dom NonEmpty a) => NonEmpty a -> a Source # csum :: (Num a, Dom NonEmpty a) => NonEmpty a -> a Source # cproduct :: (Num a, Dom NonEmpty a) => NonEmpty a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom NonEmpty a, Dom g b) => (a -> g b) -> NonEmpty a -> g () Source # ctraverse_ :: (Applicative g, Dom NonEmpty a) => (a -> g b) -> NonEmpty a -> g () Source # clast :: Dom NonEmpty a => NonEmpty a -> a Source # chead :: Dom NonEmpty a => NonEmpty a -> a Source # cfind :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> Maybe a Source # cfindIndex :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> Maybe Int Source # cfindIndices :: Dom NonEmpty a => (a -> Bool) -> NonEmpty a -> [Int] Source # celemIndex :: (Dom NonEmpty a, Eq a) => a -> NonEmpty a -> Maybe Int Source # celemIndices :: (Dom NonEmpty a, Eq a) => a -> NonEmpty a -> [Int] Source # | |
CFoldable IntMap Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom IntMap a, Monoid w) => (a -> w) -> IntMap a -> w Source # cfoldMap' :: (Dom IntMap a, Monoid m) => (a -> m) -> IntMap a -> m Source # cfold :: (Dom IntMap w, Monoid w) => IntMap w -> w Source # cfoldr :: Dom IntMap a => (a -> b -> b) -> b -> IntMap a -> b Source # cfoldlM :: (Monad m, Dom IntMap b) => (a -> b -> m a) -> a -> IntMap b -> m a Source # cfoldlM' :: (Monad m, Dom IntMap b) => (a -> b -> m a) -> a -> IntMap b -> m a Source # cfoldrM :: (Monad m, Dom IntMap a) => (a -> b -> m b) -> b -> IntMap a -> m b Source # cfoldrM' :: (Monad m, Dom IntMap a) => (a -> b -> m b) -> b -> IntMap a -> m b Source # cfoldl :: Dom IntMap a => (b -> a -> b) -> b -> IntMap a -> b Source # cfoldr' :: Dom IntMap a => (a -> b -> b) -> b -> IntMap a -> b Source # cfoldl' :: Dom IntMap a => (b -> a -> b) -> b -> IntMap a -> b Source # cbasicToList :: Dom IntMap a => IntMap a -> [a] Source # cfoldr1 :: Dom IntMap a => (a -> a -> a) -> IntMap a -> a Source # cfoldl1 :: Dom IntMap a => (a -> a -> a) -> IntMap a -> a Source # cindex :: Dom IntMap a => IntMap a -> Int -> a Source # cnull :: Dom IntMap a => IntMap a -> Bool Source # clength :: Dom IntMap a => IntMap a -> Int Source # cany :: Dom IntMap a => (a -> Bool) -> IntMap a -> Bool Source # call :: Dom IntMap a => (a -> Bool) -> IntMap a -> Bool Source # celem :: (Eq a, Dom IntMap a) => a -> IntMap a -> Bool Source # cnotElem :: (Eq a, Dom IntMap a) => a -> IntMap a -> Bool Source # cminimum :: (Ord a, Dom IntMap a) => IntMap a -> a Source # cmaximum :: (Ord a, Dom IntMap a) => IntMap a -> a Source # csum :: (Num a, Dom IntMap a) => IntMap a -> a Source # cproduct :: (Num a, Dom IntMap a) => IntMap a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom IntMap a, Dom g b) => (a -> g b) -> IntMap a -> g () Source # ctraverse_ :: (Applicative g, Dom IntMap a) => (a -> g b) -> IntMap a -> g () Source # clast :: Dom IntMap a => IntMap a -> a Source # chead :: Dom IntMap a => IntMap a -> a Source # cfind :: Dom IntMap a => (a -> Bool) -> IntMap a -> Maybe a Source # cfindIndex :: Dom IntMap a => (a -> Bool) -> IntMap a -> Maybe Int Source # cfindIndices :: Dom IntMap a => (a -> Bool) -> IntMap a -> [Int] Source # celemIndex :: (Dom IntMap a, Eq a) => a -> IntMap a -> Maybe Int Source # celemIndices :: (Dom IntMap a, Eq a) => a -> IntMap a -> [Int] Source # | |
CFoldable Seq Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Seq a, Monoid w) => (a -> w) -> Seq a -> w Source # cfoldMap' :: (Dom Seq a, Monoid m) => (a -> m) -> Seq a -> m Source # cfold :: (Dom Seq w, Monoid w) => Seq w -> w Source # cfoldr :: Dom Seq a => (a -> b -> b) -> b -> Seq a -> b Source # cfoldlM :: (Monad m, Dom Seq b) => (a -> b -> m a) -> a -> Seq b -> m a Source # cfoldlM' :: (Monad m, Dom Seq b) => (a -> b -> m a) -> a -> Seq b -> m a Source # cfoldrM :: (Monad m, Dom Seq a) => (a -> b -> m b) -> b -> Seq a -> m b Source # cfoldrM' :: (Monad m, Dom Seq a) => (a -> b -> m b) -> b -> Seq a -> m b Source # cfoldl :: Dom Seq a => (b -> a -> b) -> b -> Seq a -> b Source # cfoldr' :: Dom Seq a => (a -> b -> b) -> b -> Seq a -> b Source # cfoldl' :: Dom Seq a => (b -> a -> b) -> b -> Seq a -> b Source # cbasicToList :: Dom Seq a => Seq a -> [a] Source # cfoldr1 :: Dom Seq a => (a -> a -> a) -> Seq a -> a Source # cfoldl1 :: Dom Seq a => (a -> a -> a) -> Seq a -> a Source # cindex :: Dom Seq a => Seq a -> Int -> a Source # cnull :: Dom Seq a => Seq a -> Bool Source # clength :: Dom Seq a => Seq a -> Int Source # cany :: Dom Seq a => (a -> Bool) -> Seq a -> Bool Source # call :: Dom Seq a => (a -> Bool) -> Seq a -> Bool Source # celem :: (Eq a, Dom Seq a) => a -> Seq a -> Bool Source # cnotElem :: (Eq a, Dom Seq a) => a -> Seq a -> Bool Source # cminimum :: (Ord a, Dom Seq a) => Seq a -> a Source # cmaximum :: (Ord a, Dom Seq a) => Seq a -> a Source # csum :: (Num a, Dom Seq a) => Seq a -> a Source # cproduct :: (Num a, Dom Seq a) => Seq a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Seq a, Dom g b) => (a -> g b) -> Seq a -> g () Source # ctraverse_ :: (Applicative g, Dom Seq a) => (a -> g b) -> Seq a -> g () Source # clast :: Dom Seq a => Seq a -> a Source # chead :: Dom Seq a => Seq a -> a Source # cfind :: Dom Seq a => (a -> Bool) -> Seq a -> Maybe a Source # cfindIndex :: Dom Seq a => (a -> Bool) -> Seq a -> Maybe Int Source # cfindIndices :: Dom Seq a => (a -> Bool) -> Seq a -> [Int] Source # celemIndex :: (Dom Seq a, Eq a) => a -> Seq a -> Maybe Int Source # celemIndices :: (Dom Seq a, Eq a) => a -> Seq a -> [Int] Source # | |
CFoldable Set Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Set a, Monoid w) => (a -> w) -> Set a -> w Source # cfoldMap' :: (Dom Set a, Monoid m) => (a -> m) -> Set a -> m Source # cfold :: (Dom Set w, Monoid w) => Set w -> w Source # cfoldr :: Dom Set a => (a -> b -> b) -> b -> Set a -> b Source # cfoldlM :: (Monad m, Dom Set b) => (a -> b -> m a) -> a -> Set b -> m a Source # cfoldlM' :: (Monad m, Dom Set b) => (a -> b -> m a) -> a -> Set b -> m a Source # cfoldrM :: (Monad m, Dom Set a) => (a -> b -> m b) -> b -> Set a -> m b Source # cfoldrM' :: (Monad m, Dom Set a) => (a -> b -> m b) -> b -> Set a -> m b Source # cfoldl :: Dom Set a => (b -> a -> b) -> b -> Set a -> b Source # cfoldr' :: Dom Set a => (a -> b -> b) -> b -> Set a -> b Source # cfoldl' :: Dom Set a => (b -> a -> b) -> b -> Set a -> b Source # cbasicToList :: Dom Set a => Set a -> [a] Source # cfoldr1 :: Dom Set a => (a -> a -> a) -> Set a -> a Source # cfoldl1 :: Dom Set a => (a -> a -> a) -> Set a -> a Source # cindex :: Dom Set a => Set a -> Int -> a Source # cnull :: Dom Set a => Set a -> Bool Source # clength :: Dom Set a => Set a -> Int Source # cany :: Dom Set a => (a -> Bool) -> Set a -> Bool Source # call :: Dom Set a => (a -> Bool) -> Set a -> Bool Source # celem :: (Eq a, Dom Set a) => a -> Set a -> Bool Source # cnotElem :: (Eq a, Dom Set a) => a -> Set a -> Bool Source # cminimum :: (Ord a, Dom Set a) => Set a -> a Source # cmaximum :: (Ord a, Dom Set a) => Set a -> a Source # csum :: (Num a, Dom Set a) => Set a -> a Source # cproduct :: (Num a, Dom Set a) => Set a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Set a, Dom g b) => (a -> g b) -> Set a -> g () Source # ctraverse_ :: (Applicative g, Dom Set a) => (a -> g b) -> Set a -> g () Source # clast :: Dom Set a => Set a -> a Source # chead :: Dom Set a => Set a -> a Source # cfind :: Dom Set a => (a -> Bool) -> Set a -> Maybe a Source # cfindIndex :: Dom Set a => (a -> Bool) -> Set a -> Maybe Int Source # cfindIndices :: Dom Set a => (a -> Bool) -> Set a -> [Int] Source # celemIndex :: (Dom Set a, Eq a) => a -> Set a -> Maybe Int Source # celemIndices :: (Dom Set a, Eq a) => a -> Set a -> [Int] Source # | |
CFoldable PrimArray Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom PrimArray a, Monoid w) => (a -> w) -> PrimArray a -> w Source # cfoldMap' :: (Dom PrimArray a, Monoid m) => (a -> m) -> PrimArray a -> m Source # cfold :: (Dom PrimArray w, Monoid w) => PrimArray w -> w Source # cfoldr :: Dom PrimArray a => (a -> b -> b) -> b -> PrimArray a -> b Source # cfoldlM :: (Monad m, Dom PrimArray b) => (a -> b -> m a) -> a -> PrimArray b -> m a Source # cfoldlM' :: (Monad m, Dom PrimArray b) => (a -> b -> m a) -> a -> PrimArray b -> m a Source # cfoldrM :: (Monad m, Dom PrimArray a) => (a -> b -> m b) -> b -> PrimArray a -> m b Source # cfoldrM' :: (Monad m, Dom PrimArray a) => (a -> b -> m b) -> b -> PrimArray a -> m b Source # cfoldl :: Dom PrimArray a => (b -> a -> b) -> b -> PrimArray a -> b Source # cfoldr' :: Dom PrimArray a => (a -> b -> b) -> b -> PrimArray a -> b Source # cfoldl' :: Dom PrimArray a => (b -> a -> b) -> b -> PrimArray a -> b Source # cbasicToList :: Dom PrimArray a => PrimArray a -> [a] Source # cfoldr1 :: Dom PrimArray a => (a -> a -> a) -> PrimArray a -> a Source # cfoldl1 :: Dom PrimArray a => (a -> a -> a) -> PrimArray a -> a Source # cindex :: Dom PrimArray a => PrimArray a -> Int -> a Source # cnull :: Dom PrimArray a => PrimArray a -> Bool Source # clength :: Dom PrimArray a => PrimArray a -> Int Source # cany :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> Bool Source # call :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> Bool Source # celem :: (Eq a, Dom PrimArray a) => a -> PrimArray a -> Bool Source # cnotElem :: (Eq a, Dom PrimArray a) => a -> PrimArray a -> Bool Source # cminimum :: (Ord a, Dom PrimArray a) => PrimArray a -> a Source # cmaximum :: (Ord a, Dom PrimArray a) => PrimArray a -> a Source # csum :: (Num a, Dom PrimArray a) => PrimArray a -> a Source # cproduct :: (Num a, Dom PrimArray a) => PrimArray a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom PrimArray a, Dom g b) => (a -> g b) -> PrimArray a -> g () Source # ctraverse_ :: (Applicative g, Dom PrimArray a) => (a -> g b) -> PrimArray a -> g () Source # clast :: Dom PrimArray a => PrimArray a -> a Source # chead :: Dom PrimArray a => PrimArray a -> a Source # cfind :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> Maybe a Source # cfindIndex :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> Maybe Int Source # cfindIndices :: Dom PrimArray a => (a -> Bool) -> PrimArray a -> [Int] Source # celemIndex :: (Dom PrimArray a, Eq a) => a -> PrimArray a -> Maybe Int Source # celemIndices :: (Dom PrimArray a, Eq a) => a -> PrimArray a -> [Int] Source # | |
CFoldable SmallArray Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom SmallArray a, Monoid w) => (a -> w) -> SmallArray a -> w Source # cfoldMap' :: (Dom SmallArray a, Monoid m) => (a -> m) -> SmallArray a -> m Source # cfold :: (Dom SmallArray w, Monoid w) => SmallArray w -> w Source # cfoldr :: Dom SmallArray a => (a -> b -> b) -> b -> SmallArray a -> b Source # cfoldlM :: (Monad m, Dom SmallArray b) => (a -> b -> m a) -> a -> SmallArray b -> m a Source # cfoldlM' :: (Monad m, Dom SmallArray b) => (a -> b -> m a) -> a -> SmallArray b -> m a Source # cfoldrM :: (Monad m, Dom SmallArray a) => (a -> b -> m b) -> b -> SmallArray a -> m b Source # cfoldrM' :: (Monad m, Dom SmallArray a) => (a -> b -> m b) -> b -> SmallArray a -> m b Source # cfoldl :: Dom SmallArray a => (b -> a -> b) -> b -> SmallArray a -> b Source # cfoldr' :: Dom SmallArray a => (a -> b -> b) -> b -> SmallArray a -> b Source # cfoldl' :: Dom SmallArray a => (b -> a -> b) -> b -> SmallArray a -> b Source # cbasicToList :: Dom SmallArray a => SmallArray a -> [a] Source # cfoldr1 :: Dom SmallArray a => (a -> a -> a) -> SmallArray a -> a Source # cfoldl1 :: Dom SmallArray a => (a -> a -> a) -> SmallArray a -> a Source # cindex :: Dom SmallArray a => SmallArray a -> Int -> a Source # cnull :: Dom SmallArray a => SmallArray a -> Bool Source # clength :: Dom SmallArray a => SmallArray a -> Int Source # cany :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> Bool Source # call :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> Bool Source # celem :: (Eq a, Dom SmallArray a) => a -> SmallArray a -> Bool Source # cnotElem :: (Eq a, Dom SmallArray a) => a -> SmallArray a -> Bool Source # cminimum :: (Ord a, Dom SmallArray a) => SmallArray a -> a Source # cmaximum :: (Ord a, Dom SmallArray a) => SmallArray a -> a Source # csum :: (Num a, Dom SmallArray a) => SmallArray a -> a Source # cproduct :: (Num a, Dom SmallArray a) => SmallArray a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom SmallArray a, Dom g b) => (a -> g b) -> SmallArray a -> g () Source # ctraverse_ :: (Applicative g, Dom SmallArray a) => (a -> g b) -> SmallArray a -> g () Source # clast :: Dom SmallArray a => SmallArray a -> a Source # chead :: Dom SmallArray a => SmallArray a -> a Source # cfind :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> Maybe a Source # cfindIndex :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> Maybe Int Source # cfindIndices :: Dom SmallArray a => (a -> Bool) -> SmallArray a -> [Int] Source # celemIndex :: (Dom SmallArray a, Eq a) => a -> SmallArray a -> Maybe Int Source # celemIndices :: (Dom SmallArray a, Eq a) => a -> SmallArray a -> [Int] Source # | |
CFoldable Array Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Array a, Monoid w) => (a -> w) -> Array a -> w Source # cfoldMap' :: (Dom Array a, Monoid m) => (a -> m) -> Array a -> m Source # cfold :: (Dom Array w, Monoid w) => Array w -> w Source # cfoldr :: Dom Array a => (a -> b -> b) -> b -> Array a -> b Source # cfoldlM :: (Monad m, Dom Array b) => (a -> b -> m a) -> a -> Array b -> m a Source # cfoldlM' :: (Monad m, Dom Array b) => (a -> b -> m a) -> a -> Array b -> m a Source # cfoldrM :: (Monad m, Dom Array a) => (a -> b -> m b) -> b -> Array a -> m b Source # cfoldrM' :: (Monad m, Dom Array a) => (a -> b -> m b) -> b -> Array a -> m b Source # cfoldl :: Dom Array a => (b -> a -> b) -> b -> Array a -> b Source # cfoldr' :: Dom Array a => (a -> b -> b) -> b -> Array a -> b Source # cfoldl' :: Dom Array a => (b -> a -> b) -> b -> Array a -> b Source # cbasicToList :: Dom Array a => Array a -> [a] Source # cfoldr1 :: Dom Array a => (a -> a -> a) -> Array a -> a Source # cfoldl1 :: Dom Array a => (a -> a -> a) -> Array a -> a Source # cindex :: Dom Array a => Array a -> Int -> a Source # cnull :: Dom Array a => Array a -> Bool Source # clength :: Dom Array a => Array a -> Int Source # cany :: Dom Array a => (a -> Bool) -> Array a -> Bool Source # call :: Dom Array a => (a -> Bool) -> Array a -> Bool Source # celem :: (Eq a, Dom Array a) => a -> Array a -> Bool Source # cnotElem :: (Eq a, Dom Array a) => a -> Array a -> Bool Source # cminimum :: (Ord a, Dom Array a) => Array a -> a Source # cmaximum :: (Ord a, Dom Array a) => Array a -> a Source # csum :: (Num a, Dom Array a) => Array a -> a Source # cproduct :: (Num a, Dom Array a) => Array a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Array a, Dom g b) => (a -> g b) -> Array a -> g () Source # ctraverse_ :: (Applicative g, Dom Array a) => (a -> g b) -> Array a -> g () Source # clast :: Dom Array a => Array a -> a Source # chead :: Dom Array a => Array a -> a Source # cfind :: Dom Array a => (a -> Bool) -> Array a -> Maybe a Source # cfindIndex :: Dom Array a => (a -> Bool) -> Array a -> Maybe Int Source # cfindIndices :: Dom Array a => (a -> Bool) -> Array a -> [Int] Source # celemIndex :: (Dom Array a, Eq a) => a -> Array a -> Maybe Int Source # celemIndices :: (Dom Array a, Eq a) => a -> Array a -> [Int] Source # | |
CFoldable HashSet Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom HashSet a, Monoid w) => (a -> w) -> HashSet a -> w Source # cfoldMap' :: (Dom HashSet a, Monoid m) => (a -> m) -> HashSet a -> m Source # cfold :: (Dom HashSet w, Monoid w) => HashSet w -> w Source # cfoldr :: Dom HashSet a => (a -> b -> b) -> b -> HashSet a -> b Source # cfoldlM :: (Monad m, Dom HashSet b) => (a -> b -> m a) -> a -> HashSet b -> m a Source # cfoldlM' :: (Monad m, Dom HashSet b) => (a -> b -> m a) -> a -> HashSet b -> m a Source # cfoldrM :: (Monad m, Dom HashSet a) => (a -> b -> m b) -> b -> HashSet a -> m b Source # cfoldrM' :: (Monad m, Dom HashSet a) => (a -> b -> m b) -> b -> HashSet a -> m b Source # cfoldl :: Dom HashSet a => (b -> a -> b) -> b -> HashSet a -> b Source # cfoldr' :: Dom HashSet a => (a -> b -> b) -> b -> HashSet a -> b Source # cfoldl' :: Dom HashSet a => (b -> a -> b) -> b -> HashSet a -> b Source # cbasicToList :: Dom HashSet a => HashSet a -> [a] Source # cfoldr1 :: Dom HashSet a => (a -> a -> a) -> HashSet a -> a Source # cfoldl1 :: Dom HashSet a => (a -> a -> a) -> HashSet a -> a Source # cindex :: Dom HashSet a => HashSet a -> Int -> a Source # cnull :: Dom HashSet a => HashSet a -> Bool Source # clength :: Dom HashSet a => HashSet a -> Int Source # cany :: Dom HashSet a => (a -> Bool) -> HashSet a -> Bool Source # call :: Dom HashSet a => (a -> Bool) -> HashSet a -> Bool Source # celem :: (Eq a, Dom HashSet a) => a -> HashSet a -> Bool Source # cnotElem :: (Eq a, Dom HashSet a) => a -> HashSet a -> Bool Source # cminimum :: (Ord a, Dom HashSet a) => HashSet a -> a Source # cmaximum :: (Ord a, Dom HashSet a) => HashSet a -> a Source # csum :: (Num a, Dom HashSet a) => HashSet a -> a Source # cproduct :: (Num a, Dom HashSet a) => HashSet a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom HashSet a, Dom g b) => (a -> g b) -> HashSet a -> g () Source # ctraverse_ :: (Applicative g, Dom HashSet a) => (a -> g b) -> HashSet a -> g () Source # clast :: Dom HashSet a => HashSet a -> a Source # chead :: Dom HashSet a => HashSet a -> a Source # cfind :: Dom HashSet a => (a -> Bool) -> HashSet a -> Maybe a Source # cfindIndex :: Dom HashSet a => (a -> Bool) -> HashSet a -> Maybe Int Source # cfindIndices :: Dom HashSet a => (a -> Bool) -> HashSet a -> [Int] Source # celemIndex :: (Dom HashSet a, Eq a) => a -> HashSet a -> Maybe Int Source # celemIndices :: (Dom HashSet a, Eq a) => a -> HashSet a -> [Int] Source # | |
CFoldable Vector Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w Source # cfoldMap' :: (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m Source # cfold :: (Dom Vector w, Monoid w) => Vector w -> w Source # cfoldr :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b Source # cfoldlM :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a Source # cfoldlM' :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a Source # cfoldrM :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b Source # cfoldrM' :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b Source # cfoldl :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b Source # cfoldr' :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b Source # cfoldl' :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b Source # cbasicToList :: Dom Vector a => Vector a -> [a] Source # cfoldr1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a Source # cfoldl1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a Source # cindex :: Dom Vector a => Vector a -> Int -> a Source # cnull :: Dom Vector a => Vector a -> Bool Source # clength :: Dom Vector a => Vector a -> Int Source # cany :: Dom Vector a => (a -> Bool) -> Vector a -> Bool Source # call :: Dom Vector a => (a -> Bool) -> Vector a -> Bool Source # celem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool Source # cnotElem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool Source # cminimum :: (Ord a, Dom Vector a) => Vector a -> a Source # cmaximum :: (Ord a, Dom Vector a) => Vector a -> a Source # csum :: (Num a, Dom Vector a) => Vector a -> a Source # cproduct :: (Num a, Dom Vector a) => Vector a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Vector a, Dom g b) => (a -> g b) -> Vector a -> g () Source # ctraverse_ :: (Applicative g, Dom Vector a) => (a -> g b) -> Vector a -> g () Source # clast :: Dom Vector a => Vector a -> a Source # chead :: Dom Vector a => Vector a -> a Source # cfind :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe a Source # cfindIndex :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int Source # cfindIndices :: Dom Vector a => (a -> Bool) -> Vector a -> [Int] Source # celemIndex :: (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int Source # celemIndices :: (Dom Vector a, Eq a) => a -> Vector a -> [Int] Source # | |
CFoldable Vector Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w Source # cfoldMap' :: (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m Source # cfold :: (Dom Vector w, Monoid w) => Vector w -> w Source # cfoldr :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b Source # cfoldlM :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a Source # cfoldlM' :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a Source # cfoldrM :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b Source # cfoldrM' :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b Source # cfoldl :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b Source # cfoldr' :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b Source # cfoldl' :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b Source # cbasicToList :: Dom Vector a => Vector a -> [a] Source # cfoldr1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a Source # cfoldl1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a Source # cindex :: Dom Vector a => Vector a -> Int -> a Source # cnull :: Dom Vector a => Vector a -> Bool Source # clength :: Dom Vector a => Vector a -> Int Source # cany :: Dom Vector a => (a -> Bool) -> Vector a -> Bool Source # call :: Dom Vector a => (a -> Bool) -> Vector a -> Bool Source # celem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool Source # cnotElem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool Source # cminimum :: (Ord a, Dom Vector a) => Vector a -> a Source # cmaximum :: (Ord a, Dom Vector a) => Vector a -> a Source # csum :: (Num a, Dom Vector a) => Vector a -> a Source # cproduct :: (Num a, Dom Vector a) => Vector a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Vector a, Dom g b) => (a -> g b) -> Vector a -> g () Source # ctraverse_ :: (Applicative g, Dom Vector a) => (a -> g b) -> Vector a -> g () Source # clast :: Dom Vector a => Vector a -> a Source # chead :: Dom Vector a => Vector a -> a Source # cfind :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe a Source # cfindIndex :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int Source # cfindIndices :: Dom Vector a => (a -> Bool) -> Vector a -> [Int] Source # celemIndex :: (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int Source # celemIndices :: (Dom Vector a, Eq a) => a -> Vector a -> [Int] Source # | |
CFoldable Vector Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w Source # cfoldMap' :: (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m Source # cfold :: (Dom Vector w, Monoid w) => Vector w -> w Source # cfoldr :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b Source # cfoldlM :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a Source # cfoldlM' :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a Source # cfoldrM :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b Source # cfoldrM' :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b Source # cfoldl :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b Source # cfoldr' :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b Source # cfoldl' :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b Source # cbasicToList :: Dom Vector a => Vector a -> [a] Source # cfoldr1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a Source # cfoldl1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a Source # cindex :: Dom Vector a => Vector a -> Int -> a Source # cnull :: Dom Vector a => Vector a -> Bool Source # clength :: Dom Vector a => Vector a -> Int Source # cany :: Dom Vector a => (a -> Bool) -> Vector a -> Bool Source # call :: Dom Vector a => (a -> Bool) -> Vector a -> Bool Source # celem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool Source # cnotElem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool Source # cminimum :: (Ord a, Dom Vector a) => Vector a -> a Source # cmaximum :: (Ord a, Dom Vector a) => Vector a -> a Source # csum :: (Num a, Dom Vector a) => Vector a -> a Source # cproduct :: (Num a, Dom Vector a) => Vector a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Vector a, Dom g b) => (a -> g b) -> Vector a -> g () Source # ctraverse_ :: (Applicative g, Dom Vector a) => (a -> g b) -> Vector a -> g () Source # clast :: Dom Vector a => Vector a -> a Source # chead :: Dom Vector a => Vector a -> a Source # cfind :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe a Source # cfindIndex :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int Source # cfindIndices :: Dom Vector a => (a -> Bool) -> Vector a -> [Int] Source # celemIndex :: (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int Source # celemIndices :: (Dom Vector a, Eq a) => a -> Vector a -> [Int] Source # | |
CFoldable Vector Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w Source # cfoldMap' :: (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m Source # cfold :: (Dom Vector w, Monoid w) => Vector w -> w Source # cfoldr :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b Source # cfoldlM :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a Source # cfoldlM' :: (Monad m, Dom Vector b) => (a -> b -> m a) -> a -> Vector b -> m a Source # cfoldrM :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b Source # cfoldrM' :: (Monad m, Dom Vector a) => (a -> b -> m b) -> b -> Vector a -> m b Source # cfoldl :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b Source # cfoldr' :: Dom Vector a => (a -> b -> b) -> b -> Vector a -> b Source # cfoldl' :: Dom Vector a => (b -> a -> b) -> b -> Vector a -> b Source # cbasicToList :: Dom Vector a => Vector a -> [a] Source # cfoldr1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a Source # cfoldl1 :: Dom Vector a => (a -> a -> a) -> Vector a -> a Source # cindex :: Dom Vector a => Vector a -> Int -> a Source # cnull :: Dom Vector a => Vector a -> Bool Source # clength :: Dom Vector a => Vector a -> Int Source # cany :: Dom Vector a => (a -> Bool) -> Vector a -> Bool Source # call :: Dom Vector a => (a -> Bool) -> Vector a -> Bool Source # celem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool Source # cnotElem :: (Eq a, Dom Vector a) => a -> Vector a -> Bool Source # cminimum :: (Ord a, Dom Vector a) => Vector a -> a Source # cmaximum :: (Ord a, Dom Vector a) => Vector a -> a Source # csum :: (Num a, Dom Vector a) => Vector a -> a Source # cproduct :: (Num a, Dom Vector a) => Vector a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Vector a, Dom g b) => (a -> g b) -> Vector a -> g () Source # ctraverse_ :: (Applicative g, Dom Vector a) => (a -> g b) -> Vector a -> g () Source # clast :: Dom Vector a => Vector a -> a Source # chead :: Dom Vector a => Vector a -> a Source # cfind :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe a Source # cfindIndex :: Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int Source # cfindIndices :: Dom Vector a => (a -> Bool) -> Vector a -> [Int] Source # celemIndex :: (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int Source # celemIndices :: (Dom Vector a, Eq a) => a -> Vector a -> [Int] Source # | |
CFoldable (Either e) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Either e) a, Monoid w) => (a -> w) -> Either e a -> w Source # cfoldMap' :: (Dom (Either e) a, Monoid m) => (a -> m) -> Either e a -> m Source # cfold :: (Dom (Either e) w, Monoid w) => Either e w -> w Source # cfoldr :: Dom (Either e) a => (a -> b -> b) -> b -> Either e a -> b Source # cfoldlM :: (Monad m, Dom (Either e) b) => (a -> b -> m a) -> a -> Either e b -> m a Source # cfoldlM' :: (Monad m, Dom (Either e) b) => (a -> b -> m a) -> a -> Either e b -> m a Source # cfoldrM :: (Monad m, Dom (Either e) a) => (a -> b -> m b) -> b -> Either e a -> m b Source # cfoldrM' :: (Monad m, Dom (Either e) a) => (a -> b -> m b) -> b -> Either e a -> m b Source # cfoldl :: Dom (Either e) a => (b -> a -> b) -> b -> Either e a -> b Source # cfoldr' :: Dom (Either e) a => (a -> b -> b) -> b -> Either e a -> b Source # cfoldl' :: Dom (Either e) a => (b -> a -> b) -> b -> Either e a -> b Source # cbasicToList :: Dom (Either e) a => Either e a -> [a] Source # cfoldr1 :: Dom (Either e) a => (a -> a -> a) -> Either e a -> a Source # cfoldl1 :: Dom (Either e) a => (a -> a -> a) -> Either e a -> a Source # cindex :: Dom (Either e) a => Either e a -> Int -> a Source # cnull :: Dom (Either e) a => Either e a -> Bool Source # clength :: Dom (Either e) a => Either e a -> Int Source # cany :: Dom (Either e) a => (a -> Bool) -> Either e a -> Bool Source # call :: Dom (Either e) a => (a -> Bool) -> Either e a -> Bool Source # celem :: (Eq a, Dom (Either e) a) => a -> Either e a -> Bool Source # cnotElem :: (Eq a, Dom (Either e) a) => a -> Either e a -> Bool Source # cminimum :: (Ord a, Dom (Either e) a) => Either e a -> a Source # cmaximum :: (Ord a, Dom (Either e) a) => Either e a -> a Source # csum :: (Num a, Dom (Either e) a) => Either e a -> a Source # cproduct :: (Num a, Dom (Either e) a) => Either e a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Either e) a, Dom g b) => (a -> g b) -> Either e a -> g () Source # ctraverse_ :: (Applicative g, Dom (Either e) a) => (a -> g b) -> Either e a -> g () Source # clast :: Dom (Either e) a => Either e a -> a Source # chead :: Dom (Either e) a => Either e a -> a Source # cfind :: Dom (Either e) a => (a -> Bool) -> Either e a -> Maybe a Source # cfindIndex :: Dom (Either e) a => (a -> Bool) -> Either e a -> Maybe Int Source # cfindIndices :: Dom (Either e) a => (a -> Bool) -> Either e a -> [Int] Source # celemIndex :: (Dom (Either e) a, Eq a) => a -> Either e a -> Maybe Int Source # celemIndices :: (Dom (Either e) a, Eq a) => a -> Either e a -> [Int] Source # | |
CFoldable (V1 :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom V1 a, Monoid w) => (a -> w) -> V1 a -> w Source # cfoldMap' :: (Dom V1 a, Monoid m) => (a -> m) -> V1 a -> m Source # cfold :: (Dom V1 w, Monoid w) => V1 w -> w Source # cfoldr :: Dom V1 a => (a -> b -> b) -> b -> V1 a -> b Source # cfoldlM :: (Monad m, Dom V1 b) => (a -> b -> m a) -> a -> V1 b -> m a Source # cfoldlM' :: (Monad m, Dom V1 b) => (a -> b -> m a) -> a -> V1 b -> m a Source # cfoldrM :: (Monad m, Dom V1 a) => (a -> b -> m b) -> b -> V1 a -> m b Source # cfoldrM' :: (Monad m, Dom V1 a) => (a -> b -> m b) -> b -> V1 a -> m b Source # cfoldl :: Dom V1 a => (b -> a -> b) -> b -> V1 a -> b Source # cfoldr' :: Dom V1 a => (a -> b -> b) -> b -> V1 a -> b Source # cfoldl' :: Dom V1 a => (b -> a -> b) -> b -> V1 a -> b Source # cbasicToList :: Dom V1 a => V1 a -> [a] Source # cfoldr1 :: Dom V1 a => (a -> a -> a) -> V1 a -> a Source # cfoldl1 :: Dom V1 a => (a -> a -> a) -> V1 a -> a Source # cindex :: Dom V1 a => V1 a -> Int -> a Source # cnull :: Dom V1 a => V1 a -> Bool Source # clength :: Dom V1 a => V1 a -> Int Source # cany :: Dom V1 a => (a -> Bool) -> V1 a -> Bool Source # call :: Dom V1 a => (a -> Bool) -> V1 a -> Bool Source # celem :: (Eq a, Dom V1 a) => a -> V1 a -> Bool Source # cnotElem :: (Eq a, Dom V1 a) => a -> V1 a -> Bool Source # cminimum :: (Ord a, Dom V1 a) => V1 a -> a Source # cmaximum :: (Ord a, Dom V1 a) => V1 a -> a Source # csum :: (Num a, Dom V1 a) => V1 a -> a Source # cproduct :: (Num a, Dom V1 a) => V1 a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom V1 a, Dom g b) => (a -> g b) -> V1 a -> g () Source # ctraverse_ :: (Applicative g, Dom V1 a) => (a -> g b) -> V1 a -> g () Source # clast :: Dom V1 a => V1 a -> a Source # chead :: Dom V1 a => V1 a -> a Source # cfind :: Dom V1 a => (a -> Bool) -> V1 a -> Maybe a Source # cfindIndex :: Dom V1 a => (a -> Bool) -> V1 a -> Maybe Int Source # cfindIndices :: Dom V1 a => (a -> Bool) -> V1 a -> [Int] Source # celemIndex :: (Dom V1 a, Eq a) => a -> V1 a -> Maybe Int Source # celemIndices :: (Dom V1 a, Eq a) => a -> V1 a -> [Int] Source # | |
CFoldable (U1 :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom U1 a, Monoid w) => (a -> w) -> U1 a -> w Source # cfoldMap' :: (Dom U1 a, Monoid m) => (a -> m) -> U1 a -> m Source # cfold :: (Dom U1 w, Monoid w) => U1 w -> w Source # cfoldr :: Dom U1 a => (a -> b -> b) -> b -> U1 a -> b Source # cfoldlM :: (Monad m, Dom U1 b) => (a -> b -> m a) -> a -> U1 b -> m a Source # cfoldlM' :: (Monad m, Dom U1 b) => (a -> b -> m a) -> a -> U1 b -> m a Source # cfoldrM :: (Monad m, Dom U1 a) => (a -> b -> m b) -> b -> U1 a -> m b Source # cfoldrM' :: (Monad m, Dom U1 a) => (a -> b -> m b) -> b -> U1 a -> m b Source # cfoldl :: Dom U1 a => (b -> a -> b) -> b -> U1 a -> b Source # cfoldr' :: Dom U1 a => (a -> b -> b) -> b -> U1 a -> b Source # cfoldl' :: Dom U1 a => (b -> a -> b) -> b -> U1 a -> b Source # cbasicToList :: Dom U1 a => U1 a -> [a] Source # cfoldr1 :: Dom U1 a => (a -> a -> a) -> U1 a -> a Source # cfoldl1 :: Dom U1 a => (a -> a -> a) -> U1 a -> a Source # cindex :: Dom U1 a => U1 a -> Int -> a Source # cnull :: Dom U1 a => U1 a -> Bool Source # clength :: Dom U1 a => U1 a -> Int Source # cany :: Dom U1 a => (a -> Bool) -> U1 a -> Bool Source # call :: Dom U1 a => (a -> Bool) -> U1 a -> Bool Source # celem :: (Eq a, Dom U1 a) => a -> U1 a -> Bool Source # cnotElem :: (Eq a, Dom U1 a) => a -> U1 a -> Bool Source # cminimum :: (Ord a, Dom U1 a) => U1 a -> a Source # cmaximum :: (Ord a, Dom U1 a) => U1 a -> a Source # csum :: (Num a, Dom U1 a) => U1 a -> a Source # cproduct :: (Num a, Dom U1 a) => U1 a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom U1 a, Dom g b) => (a -> g b) -> U1 a -> g () Source # ctraverse_ :: (Applicative g, Dom U1 a) => (a -> g b) -> U1 a -> g () Source # clast :: Dom U1 a => U1 a -> a Source # chead :: Dom U1 a => U1 a -> a Source # cfind :: Dom U1 a => (a -> Bool) -> U1 a -> Maybe a Source # cfindIndex :: Dom U1 a => (a -> Bool) -> U1 a -> Maybe Int Source # cfindIndices :: Dom U1 a => (a -> Bool) -> U1 a -> [Int] Source # celemIndex :: (Dom U1 a, Eq a) => a -> U1 a -> Maybe Int Source # celemIndices :: (Dom U1 a, Eq a) => a -> U1 a -> [Int] Source # | |
CFoldable ((,) a) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom ((,) a) a0, Monoid w) => (a0 -> w) -> (a, a0) -> w Source # cfoldMap' :: (Dom ((,) a) a0, Monoid m) => (a0 -> m) -> (a, a0) -> m Source # cfold :: (Dom ((,) a) w, Monoid w) => (a, w) -> w Source # cfoldr :: Dom ((,) a) a0 => (a0 -> b -> b) -> b -> (a, a0) -> b Source # cfoldlM :: (Monad m, Dom ((,) a) b) => (a0 -> b -> m a0) -> a0 -> (a, b) -> m a0 Source # cfoldlM' :: (Monad m, Dom ((,) a) b) => (a0 -> b -> m a0) -> a0 -> (a, b) -> m a0 Source # cfoldrM :: (Monad m, Dom ((,) a) a0) => (a0 -> b -> m b) -> b -> (a, a0) -> m b Source # cfoldrM' :: (Monad m, Dom ((,) a) a0) => (a0 -> b -> m b) -> b -> (a, a0) -> m b Source # cfoldl :: Dom ((,) a) a0 => (b -> a0 -> b) -> b -> (a, a0) -> b Source # cfoldr' :: Dom ((,) a) a0 => (a0 -> b -> b) -> b -> (a, a0) -> b Source # cfoldl' :: Dom ((,) a) a0 => (b -> a0 -> b) -> b -> (a, a0) -> b Source # cbasicToList :: Dom ((,) a) a0 => (a, a0) -> [a0] Source # cfoldr1 :: Dom ((,) a) a0 => (a0 -> a0 -> a0) -> (a, a0) -> a0 Source # cfoldl1 :: Dom ((,) a) a0 => (a0 -> a0 -> a0) -> (a, a0) -> a0 Source # cindex :: Dom ((,) a) a0 => (a, a0) -> Int -> a0 Source # cnull :: Dom ((,) a) a0 => (a, a0) -> Bool Source # clength :: Dom ((,) a) a0 => (a, a0) -> Int Source # cany :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> Bool Source # call :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> Bool Source # celem :: (Eq a0, Dom ((,) a) a0) => a0 -> (a, a0) -> Bool Source # cnotElem :: (Eq a0, Dom ((,) a) a0) => a0 -> (a, a0) -> Bool Source # cminimum :: (Ord a0, Dom ((,) a) a0) => (a, a0) -> a0 Source # cmaximum :: (Ord a0, Dom ((,) a) a0) => (a, a0) -> a0 Source # csum :: (Num a0, Dom ((,) a) a0) => (a, a0) -> a0 Source # cproduct :: (Num a0, Dom ((,) a) a0) => (a, a0) -> a0 Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom ((,) a) a0, Dom g b) => (a0 -> g b) -> (a, a0) -> g () Source # ctraverse_ :: (Applicative g, Dom ((,) a) a0) => (a0 -> g b) -> (a, a0) -> g () Source # clast :: Dom ((,) a) a0 => (a, a0) -> a0 Source # chead :: Dom ((,) a) a0 => (a, a0) -> a0 Source # cfind :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> Maybe a0 Source # cfindIndex :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> Maybe Int Source # cfindIndices :: Dom ((,) a) a0 => (a0 -> Bool) -> (a, a0) -> [Int] Source # celemIndex :: (Dom ((,) a) a0, Eq a0) => a0 -> (a, a0) -> Maybe Int Source # celemIndices :: (Dom ((,) a) a0, Eq a0) => a0 -> (a, a0) -> [Int] Source # | |
CFoldable (Arg a) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Arg a) a0, Monoid w) => (a0 -> w) -> Arg a a0 -> w Source # cfoldMap' :: (Dom (Arg a) a0, Monoid m) => (a0 -> m) -> Arg a a0 -> m Source # cfold :: (Dom (Arg a) w, Monoid w) => Arg a w -> w Source # cfoldr :: Dom (Arg a) a0 => (a0 -> b -> b) -> b -> Arg a a0 -> b Source # cfoldlM :: (Monad m, Dom (Arg a) b) => (a0 -> b -> m a0) -> a0 -> Arg a b -> m a0 Source # cfoldlM' :: (Monad m, Dom (Arg a) b) => (a0 -> b -> m a0) -> a0 -> Arg a b -> m a0 Source # cfoldrM :: (Monad m, Dom (Arg a) a0) => (a0 -> b -> m b) -> b -> Arg a a0 -> m b Source # cfoldrM' :: (Monad m, Dom (Arg a) a0) => (a0 -> b -> m b) -> b -> Arg a a0 -> m b Source # cfoldl :: Dom (Arg a) a0 => (b -> a0 -> b) -> b -> Arg a a0 -> b Source # cfoldr' :: Dom (Arg a) a0 => (a0 -> b -> b) -> b -> Arg a a0 -> b Source # cfoldl' :: Dom (Arg a) a0 => (b -> a0 -> b) -> b -> Arg a a0 -> b Source # cbasicToList :: Dom (Arg a) a0 => Arg a a0 -> [a0] Source # cfoldr1 :: Dom (Arg a) a0 => (a0 -> a0 -> a0) -> Arg a a0 -> a0 Source # cfoldl1 :: Dom (Arg a) a0 => (a0 -> a0 -> a0) -> Arg a a0 -> a0 Source # cindex :: Dom (Arg a) a0 => Arg a a0 -> Int -> a0 Source # cnull :: Dom (Arg a) a0 => Arg a a0 -> Bool Source # clength :: Dom (Arg a) a0 => Arg a a0 -> Int Source # cany :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> Bool Source # call :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> Bool Source # celem :: (Eq a0, Dom (Arg a) a0) => a0 -> Arg a a0 -> Bool Source # cnotElem :: (Eq a0, Dom (Arg a) a0) => a0 -> Arg a a0 -> Bool Source # cminimum :: (Ord a0, Dom (Arg a) a0) => Arg a a0 -> a0 Source # cmaximum :: (Ord a0, Dom (Arg a) a0) => Arg a a0 -> a0 Source # csum :: (Num a0, Dom (Arg a) a0) => Arg a a0 -> a0 Source # cproduct :: (Num a0, Dom (Arg a) a0) => Arg a a0 -> a0 Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Arg a) a0, Dom g b) => (a0 -> g b) -> Arg a a0 -> g () Source # ctraverse_ :: (Applicative g, Dom (Arg a) a0) => (a0 -> g b) -> Arg a a0 -> g () Source # clast :: Dom (Arg a) a0 => Arg a a0 -> a0 Source # chead :: Dom (Arg a) a0 => Arg a a0 -> a0 Source # cfind :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> Maybe a0 Source # cfindIndex :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> Maybe Int Source # cfindIndices :: Dom (Arg a) a0 => (a0 -> Bool) -> Arg a a0 -> [Int] Source # celemIndex :: (Dom (Arg a) a0, Eq a0) => a0 -> Arg a a0 -> Maybe Int Source # celemIndices :: (Dom (Arg a) a0, Eq a0) => a0 -> Arg a a0 -> [Int] Source # | |
CFoldable (Proxy :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom Proxy a, Monoid w) => (a -> w) -> Proxy a -> w Source # cfoldMap' :: (Dom Proxy a, Monoid m) => (a -> m) -> Proxy a -> m Source # cfold :: (Dom Proxy w, Monoid w) => Proxy w -> w Source # cfoldr :: Dom Proxy a => (a -> b -> b) -> b -> Proxy a -> b Source # cfoldlM :: (Monad m, Dom Proxy b) => (a -> b -> m a) -> a -> Proxy b -> m a Source # cfoldlM' :: (Monad m, Dom Proxy b) => (a -> b -> m a) -> a -> Proxy b -> m a Source # cfoldrM :: (Monad m, Dom Proxy a) => (a -> b -> m b) -> b -> Proxy a -> m b Source # cfoldrM' :: (Monad m, Dom Proxy a) => (a -> b -> m b) -> b -> Proxy a -> m b Source # cfoldl :: Dom Proxy a => (b -> a -> b) -> b -> Proxy a -> b Source # cfoldr' :: Dom Proxy a => (a -> b -> b) -> b -> Proxy a -> b Source # cfoldl' :: Dom Proxy a => (b -> a -> b) -> b -> Proxy a -> b Source # cbasicToList :: Dom Proxy a => Proxy a -> [a] Source # cfoldr1 :: Dom Proxy a => (a -> a -> a) -> Proxy a -> a Source # cfoldl1 :: Dom Proxy a => (a -> a -> a) -> Proxy a -> a Source # cindex :: Dom Proxy a => Proxy a -> Int -> a Source # cnull :: Dom Proxy a => Proxy a -> Bool Source # clength :: Dom Proxy a => Proxy a -> Int Source # cany :: Dom Proxy a => (a -> Bool) -> Proxy a -> Bool Source # call :: Dom Proxy a => (a -> Bool) -> Proxy a -> Bool Source # celem :: (Eq a, Dom Proxy a) => a -> Proxy a -> Bool Source # cnotElem :: (Eq a, Dom Proxy a) => a -> Proxy a -> Bool Source # cminimum :: (Ord a, Dom Proxy a) => Proxy a -> a Source # cmaximum :: (Ord a, Dom Proxy a) => Proxy a -> a Source # csum :: (Num a, Dom Proxy a) => Proxy a -> a Source # cproduct :: (Num a, Dom Proxy a) => Proxy a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom Proxy a, Dom g b) => (a -> g b) -> Proxy a -> g () Source # ctraverse_ :: (Applicative g, Dom Proxy a) => (a -> g b) -> Proxy a -> g () Source # clast :: Dom Proxy a => Proxy a -> a Source # chead :: Dom Proxy a => Proxy a -> a Source # cfind :: Dom Proxy a => (a -> Bool) -> Proxy a -> Maybe a Source # cfindIndex :: Dom Proxy a => (a -> Bool) -> Proxy a -> Maybe Int Source # cfindIndices :: Dom Proxy a => (a -> Bool) -> Proxy a -> [Int] Source # celemIndex :: (Dom Proxy a, Eq a) => a -> Proxy a -> Maybe Int Source # celemIndices :: (Dom Proxy a, Eq a) => a -> Proxy a -> [Int] Source # | |
CFoldable (Map k) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Map k) a, Monoid w) => (a -> w) -> Map k a -> w Source # cfoldMap' :: (Dom (Map k) a, Monoid m) => (a -> m) -> Map k a -> m Source # cfold :: (Dom (Map k) w, Monoid w) => Map k w -> w Source # cfoldr :: Dom (Map k) a => (a -> b -> b) -> b -> Map k a -> b Source # cfoldlM :: (Monad m, Dom (Map k) b) => (a -> b -> m a) -> a -> Map k b -> m a Source # cfoldlM' :: (Monad m, Dom (Map k) b) => (a -> b -> m a) -> a -> Map k b -> m a Source # cfoldrM :: (Monad m, Dom (Map k) a) => (a -> b -> m b) -> b -> Map k a -> m b Source # cfoldrM' :: (Monad m, Dom (Map k) a) => (a -> b -> m b) -> b -> Map k a -> m b Source # cfoldl :: Dom (Map k) a => (b -> a -> b) -> b -> Map k a -> b Source # cfoldr' :: Dom (Map k) a => (a -> b -> b) -> b -> Map k a -> b Source # cfoldl' :: Dom (Map k) a => (b -> a -> b) -> b -> Map k a -> b Source # cbasicToList :: Dom (Map k) a => Map k a -> [a] Source # cfoldr1 :: Dom (Map k) a => (a -> a -> a) -> Map k a -> a Source # cfoldl1 :: Dom (Map k) a => (a -> a -> a) -> Map k a -> a Source # cindex :: Dom (Map k) a => Map k a -> Int -> a Source # cnull :: Dom (Map k) a => Map k a -> Bool Source # clength :: Dom (Map k) a => Map k a -> Int Source # cany :: Dom (Map k) a => (a -> Bool) -> Map k a -> Bool Source # call :: Dom (Map k) a => (a -> Bool) -> Map k a -> Bool Source # celem :: (Eq a, Dom (Map k) a) => a -> Map k a -> Bool Source # cnotElem :: (Eq a, Dom (Map k) a) => a -> Map k a -> Bool Source # cminimum :: (Ord a, Dom (Map k) a) => Map k a -> a Source # cmaximum :: (Ord a, Dom (Map k) a) => Map k a -> a Source # csum :: (Num a, Dom (Map k) a) => Map k a -> a Source # cproduct :: (Num a, Dom (Map k) a) => Map k a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Map k) a, Dom g b) => (a -> g b) -> Map k a -> g () Source # ctraverse_ :: (Applicative g, Dom (Map k) a) => (a -> g b) -> Map k a -> g () Source # clast :: Dom (Map k) a => Map k a -> a Source # chead :: Dom (Map k) a => Map k a -> a Source # cfind :: Dom (Map k) a => (a -> Bool) -> Map k a -> Maybe a Source # cfindIndex :: Dom (Map k) a => (a -> Bool) -> Map k a -> Maybe Int Source # cfindIndices :: Dom (Map k) a => (a -> Bool) -> Map k a -> [Int] Source # celemIndex :: (Dom (Map k) a, Eq a) => a -> Map k a -> Maybe Int Source # celemIndices :: (Dom (Map k) a, Eq a) => a -> Map k a -> [Int] Source # | |
CFoldable (HashMap k) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (HashMap k) a, Monoid w) => (a -> w) -> HashMap k a -> w Source # cfoldMap' :: (Dom (HashMap k) a, Monoid m) => (a -> m) -> HashMap k a -> m Source # cfold :: (Dom (HashMap k) w, Monoid w) => HashMap k w -> w Source # cfoldr :: Dom (HashMap k) a => (a -> b -> b) -> b -> HashMap k a -> b Source # cfoldlM :: (Monad m, Dom (HashMap k) b) => (a -> b -> m a) -> a -> HashMap k b -> m a Source # cfoldlM' :: (Monad m, Dom (HashMap k) b) => (a -> b -> m a) -> a -> HashMap k b -> m a Source # cfoldrM :: (Monad m, Dom (HashMap k) a) => (a -> b -> m b) -> b -> HashMap k a -> m b Source # cfoldrM' :: (Monad m, Dom (HashMap k) a) => (a -> b -> m b) -> b -> HashMap k a -> m b Source # cfoldl :: Dom (HashMap k) a => (b -> a -> b) -> b -> HashMap k a -> b Source # cfoldr' :: Dom (HashMap k) a => (a -> b -> b) -> b -> HashMap k a -> b Source # cfoldl' :: Dom (HashMap k) a => (b -> a -> b) -> b -> HashMap k a -> b Source # cbasicToList :: Dom (HashMap k) a => HashMap k a -> [a] Source # cfoldr1 :: Dom (HashMap k) a => (a -> a -> a) -> HashMap k a -> a Source # cfoldl1 :: Dom (HashMap k) a => (a -> a -> a) -> HashMap k a -> a Source # cindex :: Dom (HashMap k) a => HashMap k a -> Int -> a Source # cnull :: Dom (HashMap k) a => HashMap k a -> Bool Source # clength :: Dom (HashMap k) a => HashMap k a -> Int Source # cany :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> Bool Source # call :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> Bool Source # celem :: (Eq a, Dom (HashMap k) a) => a -> HashMap k a -> Bool Source # cnotElem :: (Eq a, Dom (HashMap k) a) => a -> HashMap k a -> Bool Source # cminimum :: (Ord a, Dom (HashMap k) a) => HashMap k a -> a Source # cmaximum :: (Ord a, Dom (HashMap k) a) => HashMap k a -> a Source # csum :: (Num a, Dom (HashMap k) a) => HashMap k a -> a Source # cproduct :: (Num a, Dom (HashMap k) a) => HashMap k a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (HashMap k) a, Dom g b) => (a -> g b) -> HashMap k a -> g () Source # ctraverse_ :: (Applicative g, Dom (HashMap k) a) => (a -> g b) -> HashMap k a -> g () Source # clast :: Dom (HashMap k) a => HashMap k a -> a Source # chead :: Dom (HashMap k) a => HashMap k a -> a Source # cfind :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> Maybe a Source # cfindIndex :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> Maybe Int Source # cfindIndices :: Dom (HashMap k) a => (a -> Bool) -> HashMap k a -> [Int] Source # celemIndex :: (Dom (HashMap k) a, Eq a) => a -> HashMap k a -> Maybe Int Source # celemIndices :: (Dom (HashMap k) a, Eq a) => a -> HashMap k a -> [Int] Source # | |
Foldable f => CFoldable (WrapFunctor f) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (WrapFunctor f) a, Monoid w) => (a -> w) -> WrapFunctor f a -> w Source # cfoldMap' :: (Dom (WrapFunctor f) a, Monoid m) => (a -> m) -> WrapFunctor f a -> m Source # cfold :: (Dom (WrapFunctor f) w, Monoid w) => WrapFunctor f w -> w Source # cfoldr :: Dom (WrapFunctor f) a => (a -> b -> b) -> b -> WrapFunctor f a -> b Source # cfoldlM :: (Monad m, Dom (WrapFunctor f) b) => (a -> b -> m a) -> a -> WrapFunctor f b -> m a Source # cfoldlM' :: (Monad m, Dom (WrapFunctor f) b) => (a -> b -> m a) -> a -> WrapFunctor f b -> m a Source # cfoldrM :: (Monad m, Dom (WrapFunctor f) a) => (a -> b -> m b) -> b -> WrapFunctor f a -> m b Source # cfoldrM' :: (Monad m, Dom (WrapFunctor f) a) => (a -> b -> m b) -> b -> WrapFunctor f a -> m b Source # cfoldl :: Dom (WrapFunctor f) a => (b -> a -> b) -> b -> WrapFunctor f a -> b Source # cfoldr' :: Dom (WrapFunctor f) a => (a -> b -> b) -> b -> WrapFunctor f a -> b Source # cfoldl' :: Dom (WrapFunctor f) a => (b -> a -> b) -> b -> WrapFunctor f a -> b Source # cbasicToList :: Dom (WrapFunctor f) a => WrapFunctor f a -> [a] Source # cfoldr1 :: Dom (WrapFunctor f) a => (a -> a -> a) -> WrapFunctor f a -> a Source # cfoldl1 :: Dom (WrapFunctor f) a => (a -> a -> a) -> WrapFunctor f a -> a Source # cindex :: Dom (WrapFunctor f) a => WrapFunctor f a -> Int -> a Source # cnull :: Dom (WrapFunctor f) a => WrapFunctor f a -> Bool Source # clength :: Dom (WrapFunctor f) a => WrapFunctor f a -> Int Source # cany :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> Bool Source # call :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> Bool Source # celem :: (Eq a, Dom (WrapFunctor f) a) => a -> WrapFunctor f a -> Bool Source # cnotElem :: (Eq a, Dom (WrapFunctor f) a) => a -> WrapFunctor f a -> Bool Source # cminimum :: (Ord a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a Source # cmaximum :: (Ord a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a Source # csum :: (Num a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a Source # cproduct :: (Num a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (WrapFunctor f) a, Dom g b) => (a -> g b) -> WrapFunctor f a -> g () Source # ctraverse_ :: (Applicative g, Dom (WrapFunctor f) a) => (a -> g b) -> WrapFunctor f a -> g () Source # clast :: Dom (WrapFunctor f) a => WrapFunctor f a -> a Source # chead :: Dom (WrapFunctor f) a => WrapFunctor f a -> a Source # cfind :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> Maybe a Source # cfindIndex :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> Maybe Int Source # cfindIndices :: Dom (WrapFunctor f) a => (a -> Bool) -> WrapFunctor f a -> [Int] Source # celemIndex :: (Dom (WrapFunctor f) a, Eq a) => a -> WrapFunctor f a -> Maybe Int Source # celemIndices :: (Dom (WrapFunctor f) a, Eq a) => a -> WrapFunctor f a -> [Int] Source # | |
Foldable f => CFoldable (Rec1 f) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Rec1 f) a, Monoid w) => (a -> w) -> Rec1 f a -> w Source # cfoldMap' :: (Dom (Rec1 f) a, Monoid m) => (a -> m) -> Rec1 f a -> m Source # cfold :: (Dom (Rec1 f) w, Monoid w) => Rec1 f w -> w Source # cfoldr :: Dom (Rec1 f) a => (a -> b -> b) -> b -> Rec1 f a -> b Source # cfoldlM :: (Monad m, Dom (Rec1 f) b) => (a -> b -> m a) -> a -> Rec1 f b -> m a Source # cfoldlM' :: (Monad m, Dom (Rec1 f) b) => (a -> b -> m a) -> a -> Rec1 f b -> m a Source # cfoldrM :: (Monad m, Dom (Rec1 f) a) => (a -> b -> m b) -> b -> Rec1 f a -> m b Source # cfoldrM' :: (Monad m, Dom (Rec1 f) a) => (a -> b -> m b) -> b -> Rec1 f a -> m b Source # cfoldl :: Dom (Rec1 f) a => (b -> a -> b) -> b -> Rec1 f a -> b Source # cfoldr' :: Dom (Rec1 f) a => (a -> b -> b) -> b -> Rec1 f a -> b Source # cfoldl' :: Dom (Rec1 f) a => (b -> a -> b) -> b -> Rec1 f a -> b Source # cbasicToList :: Dom (Rec1 f) a => Rec1 f a -> [a] Source # cfoldr1 :: Dom (Rec1 f) a => (a -> a -> a) -> Rec1 f a -> a Source # cfoldl1 :: Dom (Rec1 f) a => (a -> a -> a) -> Rec1 f a -> a Source # cindex :: Dom (Rec1 f) a => Rec1 f a -> Int -> a Source # cnull :: Dom (Rec1 f) a => Rec1 f a -> Bool Source # clength :: Dom (Rec1 f) a => Rec1 f a -> Int Source # cany :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> Bool Source # call :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> Bool Source # celem :: (Eq a, Dom (Rec1 f) a) => a -> Rec1 f a -> Bool Source # cnotElem :: (Eq a, Dom (Rec1 f) a) => a -> Rec1 f a -> Bool Source # cminimum :: (Ord a, Dom (Rec1 f) a) => Rec1 f a -> a Source # cmaximum :: (Ord a, Dom (Rec1 f) a) => Rec1 f a -> a Source # csum :: (Num a, Dom (Rec1 f) a) => Rec1 f a -> a Source # cproduct :: (Num a, Dom (Rec1 f) a) => Rec1 f a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Rec1 f) a, Dom g b) => (a -> g b) -> Rec1 f a -> g () Source # ctraverse_ :: (Applicative g, Dom (Rec1 f) a) => (a -> g b) -> Rec1 f a -> g () Source # clast :: Dom (Rec1 f) a => Rec1 f a -> a Source # chead :: Dom (Rec1 f) a => Rec1 f a -> a Source # cfind :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> Maybe a Source # cfindIndex :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> Maybe Int Source # cfindIndices :: Dom (Rec1 f) a => (a -> Bool) -> Rec1 f a -> [Int] Source # celemIndex :: (Dom (Rec1 f) a, Eq a) => a -> Rec1 f a -> Maybe Int Source # celemIndices :: (Dom (Rec1 f) a, Eq a) => a -> Rec1 f a -> [Int] Source # | |
CFoldable (URec Char :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (URec Char) a, Monoid w) => (a -> w) -> URec Char a -> w Source # cfoldMap' :: (Dom (URec Char) a, Monoid m) => (a -> m) -> URec Char a -> m Source # cfold :: (Dom (URec Char) w, Monoid w) => URec Char w -> w Source # cfoldr :: Dom (URec Char) a => (a -> b -> b) -> b -> URec Char a -> b Source # cfoldlM :: (Monad m, Dom (URec Char) b) => (a -> b -> m a) -> a -> URec Char b -> m a Source # cfoldlM' :: (Monad m, Dom (URec Char) b) => (a -> b -> m a) -> a -> URec Char b -> m a Source # cfoldrM :: (Monad m, Dom (URec Char) a) => (a -> b -> m b) -> b -> URec Char a -> m b Source # cfoldrM' :: (Monad m, Dom (URec Char) a) => (a -> b -> m b) -> b -> URec Char a -> m b Source # cfoldl :: Dom (URec Char) a => (b -> a -> b) -> b -> URec Char a -> b Source # cfoldr' :: Dom (URec Char) a => (a -> b -> b) -> b -> URec Char a -> b Source # cfoldl' :: Dom (URec Char) a => (b -> a -> b) -> b -> URec Char a -> b Source # cbasicToList :: Dom (URec Char) a => URec Char a -> [a] Source # cfoldr1 :: Dom (URec Char) a => (a -> a -> a) -> URec Char a -> a Source # cfoldl1 :: Dom (URec Char) a => (a -> a -> a) -> URec Char a -> a Source # cindex :: Dom (URec Char) a => URec Char a -> Int -> a Source # cnull :: Dom (URec Char) a => URec Char a -> Bool Source # clength :: Dom (URec Char) a => URec Char a -> Int Source # cany :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> Bool Source # call :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> Bool Source # celem :: (Eq a, Dom (URec Char) a) => a -> URec Char a -> Bool Source # cnotElem :: (Eq a, Dom (URec Char) a) => a -> URec Char a -> Bool Source # cminimum :: (Ord a, Dom (URec Char) a) => URec Char a -> a Source # cmaximum :: (Ord a, Dom (URec Char) a) => URec Char a -> a Source # csum :: (Num a, Dom (URec Char) a) => URec Char a -> a Source # cproduct :: (Num a, Dom (URec Char) a) => URec Char a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Char) a, Dom g b) => (a -> g b) -> URec Char a -> g () Source # ctraverse_ :: (Applicative g, Dom (URec Char) a) => (a -> g b) -> URec Char a -> g () Source # clast :: Dom (URec Char) a => URec Char a -> a Source # chead :: Dom (URec Char) a => URec Char a -> a Source # cfind :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> Maybe a Source # cfindIndex :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> Maybe Int Source # cfindIndices :: Dom (URec Char) a => (a -> Bool) -> URec Char a -> [Int] Source # celemIndex :: (Dom (URec Char) a, Eq a) => a -> URec Char a -> Maybe Int Source # celemIndices :: (Dom (URec Char) a, Eq a) => a -> URec Char a -> [Int] Source # | |
CFoldable (URec Double :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (URec Double) a, Monoid w) => (a -> w) -> URec Double a -> w Source # cfoldMap' :: (Dom (URec Double) a, Monoid m) => (a -> m) -> URec Double a -> m Source # cfold :: (Dom (URec Double) w, Monoid w) => URec Double w -> w Source # cfoldr :: Dom (URec Double) a => (a -> b -> b) -> b -> URec Double a -> b Source # cfoldlM :: (Monad m, Dom (URec Double) b) => (a -> b -> m a) -> a -> URec Double b -> m a Source # cfoldlM' :: (Monad m, Dom (URec Double) b) => (a -> b -> m a) -> a -> URec Double b -> m a Source # cfoldrM :: (Monad m, Dom (URec Double) a) => (a -> b -> m b) -> b -> URec Double a -> m b Source # cfoldrM' :: (Monad m, Dom (URec Double) a) => (a -> b -> m b) -> b -> URec Double a -> m b Source # cfoldl :: Dom (URec Double) a => (b -> a -> b) -> b -> URec Double a -> b Source # cfoldr' :: Dom (URec Double) a => (a -> b -> b) -> b -> URec Double a -> b Source # cfoldl' :: Dom (URec Double) a => (b -> a -> b) -> b -> URec Double a -> b Source # cbasicToList :: Dom (URec Double) a => URec Double a -> [a] Source # cfoldr1 :: Dom (URec Double) a => (a -> a -> a) -> URec Double a -> a Source # cfoldl1 :: Dom (URec Double) a => (a -> a -> a) -> URec Double a -> a Source # cindex :: Dom (URec Double) a => URec Double a -> Int -> a Source # cnull :: Dom (URec Double) a => URec Double a -> Bool Source # clength :: Dom (URec Double) a => URec Double a -> Int Source # cany :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> Bool Source # call :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> Bool Source # celem :: (Eq a, Dom (URec Double) a) => a -> URec Double a -> Bool Source # cnotElem :: (Eq a, Dom (URec Double) a) => a -> URec Double a -> Bool Source # cminimum :: (Ord a, Dom (URec Double) a) => URec Double a -> a Source # cmaximum :: (Ord a, Dom (URec Double) a) => URec Double a -> a Source # csum :: (Num a, Dom (URec Double) a) => URec Double a -> a Source # cproduct :: (Num a, Dom (URec Double) a) => URec Double a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Double) a, Dom g b) => (a -> g b) -> URec Double a -> g () Source # ctraverse_ :: (Applicative g, Dom (URec Double) a) => (a -> g b) -> URec Double a -> g () Source # clast :: Dom (URec Double) a => URec Double a -> a Source # chead :: Dom (URec Double) a => URec Double a -> a Source # cfind :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> Maybe a Source # cfindIndex :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> Maybe Int Source # cfindIndices :: Dom (URec Double) a => (a -> Bool) -> URec Double a -> [Int] Source # celemIndex :: (Dom (URec Double) a, Eq a) => a -> URec Double a -> Maybe Int Source # celemIndices :: (Dom (URec Double) a, Eq a) => a -> URec Double a -> [Int] Source # | |
CFoldable (URec Float :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (URec Float) a, Monoid w) => (a -> w) -> URec Float a -> w Source # cfoldMap' :: (Dom (URec Float) a, Monoid m) => (a -> m) -> URec Float a -> m Source # cfold :: (Dom (URec Float) w, Monoid w) => URec Float w -> w Source # cfoldr :: Dom (URec Float) a => (a -> b -> b) -> b -> URec Float a -> b Source # cfoldlM :: (Monad m, Dom (URec Float) b) => (a -> b -> m a) -> a -> URec Float b -> m a Source # cfoldlM' :: (Monad m, Dom (URec Float) b) => (a -> b -> m a) -> a -> URec Float b -> m a Source # cfoldrM :: (Monad m, Dom (URec Float) a) => (a -> b -> m b) -> b -> URec Float a -> m b Source # cfoldrM' :: (Monad m, Dom (URec Float) a) => (a -> b -> m b) -> b -> URec Float a -> m b Source # cfoldl :: Dom (URec Float) a => (b -> a -> b) -> b -> URec Float a -> b Source # cfoldr' :: Dom (URec Float) a => (a -> b -> b) -> b -> URec Float a -> b Source # cfoldl' :: Dom (URec Float) a => (b -> a -> b) -> b -> URec Float a -> b Source # cbasicToList :: Dom (URec Float) a => URec Float a -> [a] Source # cfoldr1 :: Dom (URec Float) a => (a -> a -> a) -> URec Float a -> a Source # cfoldl1 :: Dom (URec Float) a => (a -> a -> a) -> URec Float a -> a Source # cindex :: Dom (URec Float) a => URec Float a -> Int -> a Source # cnull :: Dom (URec Float) a => URec Float a -> Bool Source # clength :: Dom (URec Float) a => URec Float a -> Int Source # cany :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> Bool Source # call :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> Bool Source # celem :: (Eq a, Dom (URec Float) a) => a -> URec Float a -> Bool Source # cnotElem :: (Eq a, Dom (URec Float) a) => a -> URec Float a -> Bool Source # cminimum :: (Ord a, Dom (URec Float) a) => URec Float a -> a Source # cmaximum :: (Ord a, Dom (URec Float) a) => URec Float a -> a Source # csum :: (Num a, Dom (URec Float) a) => URec Float a -> a Source # cproduct :: (Num a, Dom (URec Float) a) => URec Float a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Float) a, Dom g b) => (a -> g b) -> URec Float a -> g () Source # ctraverse_ :: (Applicative g, Dom (URec Float) a) => (a -> g b) -> URec Float a -> g () Source # clast :: Dom (URec Float) a => URec Float a -> a Source # chead :: Dom (URec Float) a => URec Float a -> a Source # cfind :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> Maybe a Source # cfindIndex :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> Maybe Int Source # cfindIndices :: Dom (URec Float) a => (a -> Bool) -> URec Float a -> [Int] Source # celemIndex :: (Dom (URec Float) a, Eq a) => a -> URec Float a -> Maybe Int Source # celemIndices :: (Dom (URec Float) a, Eq a) => a -> URec Float a -> [Int] Source # | |
CFoldable (URec Int :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (URec Int) a, Monoid w) => (a -> w) -> URec Int a -> w Source # cfoldMap' :: (Dom (URec Int) a, Monoid m) => (a -> m) -> URec Int a -> m Source # cfold :: (Dom (URec Int) w, Monoid w) => URec Int w -> w Source # cfoldr :: Dom (URec Int) a => (a -> b -> b) -> b -> URec Int a -> b Source # cfoldlM :: (Monad m, Dom (URec Int) b) => (a -> b -> m a) -> a -> URec Int b -> m a Source # cfoldlM' :: (Monad m, Dom (URec Int) b) => (a -> b -> m a) -> a -> URec Int b -> m a Source # cfoldrM :: (Monad m, Dom (URec Int) a) => (a -> b -> m b) -> b -> URec Int a -> m b Source # cfoldrM' :: (Monad m, Dom (URec Int) a) => (a -> b -> m b) -> b -> URec Int a -> m b Source # cfoldl :: Dom (URec Int) a => (b -> a -> b) -> b -> URec Int a -> b Source # cfoldr' :: Dom (URec Int) a => (a -> b -> b) -> b -> URec Int a -> b Source # cfoldl' :: Dom (URec Int) a => (b -> a -> b) -> b -> URec Int a -> b Source # cbasicToList :: Dom (URec Int) a => URec Int a -> [a] Source # cfoldr1 :: Dom (URec Int) a => (a -> a -> a) -> URec Int a -> a Source # cfoldl1 :: Dom (URec Int) a => (a -> a -> a) -> URec Int a -> a Source # cindex :: Dom (URec Int) a => URec Int a -> Int -> a Source # cnull :: Dom (URec Int) a => URec Int a -> Bool Source # clength :: Dom (URec Int) a => URec Int a -> Int Source # cany :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> Bool Source # call :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> Bool Source # celem :: (Eq a, Dom (URec Int) a) => a -> URec Int a -> Bool Source # cnotElem :: (Eq a, Dom (URec Int) a) => a -> URec Int a -> Bool Source # cminimum :: (Ord a, Dom (URec Int) a) => URec Int a -> a Source # cmaximum :: (Ord a, Dom (URec Int) a) => URec Int a -> a Source # csum :: (Num a, Dom (URec Int) a) => URec Int a -> a Source # cproduct :: (Num a, Dom (URec Int) a) => URec Int a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Int) a, Dom g b) => (a -> g b) -> URec Int a -> g () Source # ctraverse_ :: (Applicative g, Dom (URec Int) a) => (a -> g b) -> URec Int a -> g () Source # clast :: Dom (URec Int) a => URec Int a -> a Source # chead :: Dom (URec Int) a => URec Int a -> a Source # cfind :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> Maybe a Source # cfindIndex :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> Maybe Int Source # cfindIndices :: Dom (URec Int) a => (a -> Bool) -> URec Int a -> [Int] Source # celemIndex :: (Dom (URec Int) a, Eq a) => a -> URec Int a -> Maybe Int Source # celemIndices :: (Dom (URec Int) a, Eq a) => a -> URec Int a -> [Int] Source # | |
CFoldable (URec Word :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (URec Word) a, Monoid w) => (a -> w) -> URec Word a -> w Source # cfoldMap' :: (Dom (URec Word) a, Monoid m) => (a -> m) -> URec Word a -> m Source # cfold :: (Dom (URec Word) w, Monoid w) => URec Word w -> w Source # cfoldr :: Dom (URec Word) a => (a -> b -> b) -> b -> URec Word a -> b Source # cfoldlM :: (Monad m, Dom (URec Word) b) => (a -> b -> m a) -> a -> URec Word b -> m a Source # cfoldlM' :: (Monad m, Dom (URec Word) b) => (a -> b -> m a) -> a -> URec Word b -> m a Source # cfoldrM :: (Monad m, Dom (URec Word) a) => (a -> b -> m b) -> b -> URec Word a -> m b Source # cfoldrM' :: (Monad m, Dom (URec Word) a) => (a -> b -> m b) -> b -> URec Word a -> m b Source # cfoldl :: Dom (URec Word) a => (b -> a -> b) -> b -> URec Word a -> b Source # cfoldr' :: Dom (URec Word) a => (a -> b -> b) -> b -> URec Word a -> b Source # cfoldl' :: Dom (URec Word) a => (b -> a -> b) -> b -> URec Word a -> b Source # cbasicToList :: Dom (URec Word) a => URec Word a -> [a] Source # cfoldr1 :: Dom (URec Word) a => (a -> a -> a) -> URec Word a -> a Source # cfoldl1 :: Dom (URec Word) a => (a -> a -> a) -> URec Word a -> a Source # cindex :: Dom (URec Word) a => URec Word a -> Int -> a Source # cnull :: Dom (URec Word) a => URec Word a -> Bool Source # clength :: Dom (URec Word) a => URec Word a -> Int Source # cany :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> Bool Source # call :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> Bool Source # celem :: (Eq a, Dom (URec Word) a) => a -> URec Word a -> Bool Source # cnotElem :: (Eq a, Dom (URec Word) a) => a -> URec Word a -> Bool Source # cminimum :: (Ord a, Dom (URec Word) a) => URec Word a -> a Source # cmaximum :: (Ord a, Dom (URec Word) a) => URec Word a -> a Source # csum :: (Num a, Dom (URec Word) a) => URec Word a -> a Source # cproduct :: (Num a, Dom (URec Word) a) => URec Word a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec Word) a, Dom g b) => (a -> g b) -> URec Word a -> g () Source # ctraverse_ :: (Applicative g, Dom (URec Word) a) => (a -> g b) -> URec Word a -> g () Source # clast :: Dom (URec Word) a => URec Word a -> a Source # chead :: Dom (URec Word) a => URec Word a -> a Source # cfind :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> Maybe a Source # cfindIndex :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> Maybe Int Source # cfindIndices :: Dom (URec Word) a => (a -> Bool) -> URec Word a -> [Int] Source # celemIndex :: (Dom (URec Word) a, Eq a) => a -> URec Word a -> Maybe Int Source # celemIndices :: (Dom (URec Word) a, Eq a) => a -> URec Word a -> [Int] Source # | |
CFoldable (URec (Ptr ()) :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (URec (Ptr ())) a, Monoid w) => (a -> w) -> URec (Ptr ()) a -> w Source # cfoldMap' :: (Dom (URec (Ptr ())) a, Monoid m) => (a -> m) -> URec (Ptr ()) a -> m Source # cfold :: (Dom (URec (Ptr ())) w, Monoid w) => URec (Ptr ()) w -> w Source # cfoldr :: Dom (URec (Ptr ())) a => (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source # cfoldlM :: (Monad m, Dom (URec (Ptr ())) b) => (a -> b -> m a) -> a -> URec (Ptr ()) b -> m a Source # cfoldlM' :: (Monad m, Dom (URec (Ptr ())) b) => (a -> b -> m a) -> a -> URec (Ptr ()) b -> m a Source # cfoldrM :: (Monad m, Dom (URec (Ptr ())) a) => (a -> b -> m b) -> b -> URec (Ptr ()) a -> m b Source # cfoldrM' :: (Monad m, Dom (URec (Ptr ())) a) => (a -> b -> m b) -> b -> URec (Ptr ()) a -> m b Source # cfoldl :: Dom (URec (Ptr ())) a => (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source # cfoldr' :: Dom (URec (Ptr ())) a => (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source # cfoldl' :: Dom (URec (Ptr ())) a => (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source # cbasicToList :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> [a] Source # cfoldr1 :: Dom (URec (Ptr ())) a => (a -> a -> a) -> URec (Ptr ()) a -> a Source # cfoldl1 :: Dom (URec (Ptr ())) a => (a -> a -> a) -> URec (Ptr ()) a -> a Source # cindex :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> Int -> a Source # cnull :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> Bool Source # clength :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> Int Source # cany :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> Bool Source # call :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> Bool Source # celem :: (Eq a, Dom (URec (Ptr ())) a) => a -> URec (Ptr ()) a -> Bool Source # cnotElem :: (Eq a, Dom (URec (Ptr ())) a) => a -> URec (Ptr ()) a -> Bool Source # cminimum :: (Ord a, Dom (URec (Ptr ())) a) => URec (Ptr ()) a -> a Source # cmaximum :: (Ord a, Dom (URec (Ptr ())) a) => URec (Ptr ()) a -> a Source # csum :: (Num a, Dom (URec (Ptr ())) a) => URec (Ptr ()) a -> a Source # cproduct :: (Num a, Dom (URec (Ptr ())) a) => URec (Ptr ()) a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (URec (Ptr ())) a, Dom g b) => (a -> g b) -> URec (Ptr ()) a -> g () Source # ctraverse_ :: (Applicative g, Dom (URec (Ptr ())) a) => (a -> g b) -> URec (Ptr ()) a -> g () Source # clast :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> a Source # chead :: Dom (URec (Ptr ())) a => URec (Ptr ()) a -> a Source # cfind :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> Maybe a Source # cfindIndex :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> Maybe Int Source # cfindIndices :: Dom (URec (Ptr ())) a => (a -> Bool) -> URec (Ptr ()) a -> [Int] Source # celemIndex :: (Dom (URec (Ptr ())) a, Eq a) => a -> URec (Ptr ()) a -> Maybe Int Source # celemIndices :: (Dom (URec (Ptr ())) a, Eq a) => a -> URec (Ptr ()) a -> [Int] Source # | |
CFoldable (Const m :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Const m) a, Monoid w) => (a -> w) -> Const m a -> w Source # cfoldMap' :: (Dom (Const m) a, Monoid m0) => (a -> m0) -> Const m a -> m0 Source # cfold :: (Dom (Const m) w, Monoid w) => Const m w -> w Source # cfoldr :: Dom (Const m) a => (a -> b -> b) -> b -> Const m a -> b Source # cfoldlM :: (Monad m0, Dom (Const m) b) => (a -> b -> m0 a) -> a -> Const m b -> m0 a Source # cfoldlM' :: (Monad m0, Dom (Const m) b) => (a -> b -> m0 a) -> a -> Const m b -> m0 a Source # cfoldrM :: (Monad m0, Dom (Const m) a) => (a -> b -> m0 b) -> b -> Const m a -> m0 b Source # cfoldrM' :: (Monad m0, Dom (Const m) a) => (a -> b -> m0 b) -> b -> Const m a -> m0 b Source # cfoldl :: Dom (Const m) a => (b -> a -> b) -> b -> Const m a -> b Source # cfoldr' :: Dom (Const m) a => (a -> b -> b) -> b -> Const m a -> b Source # cfoldl' :: Dom (Const m) a => (b -> a -> b) -> b -> Const m a -> b Source # cbasicToList :: Dom (Const m) a => Const m a -> [a] Source # cfoldr1 :: Dom (Const m) a => (a -> a -> a) -> Const m a -> a Source # cfoldl1 :: Dom (Const m) a => (a -> a -> a) -> Const m a -> a Source # cindex :: Dom (Const m) a => Const m a -> Int -> a Source # cnull :: Dom (Const m) a => Const m a -> Bool Source # clength :: Dom (Const m) a => Const m a -> Int Source # cany :: Dom (Const m) a => (a -> Bool) -> Const m a -> Bool Source # call :: Dom (Const m) a => (a -> Bool) -> Const m a -> Bool Source # celem :: (Eq a, Dom (Const m) a) => a -> Const m a -> Bool Source # cnotElem :: (Eq a, Dom (Const m) a) => a -> Const m a -> Bool Source # cminimum :: (Ord a, Dom (Const m) a) => Const m a -> a Source # cmaximum :: (Ord a, Dom (Const m) a) => Const m a -> a Source # csum :: (Num a, Dom (Const m) a) => Const m a -> a Source # cproduct :: (Num a, Dom (Const m) a) => Const m a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Const m) a, Dom g b) => (a -> g b) -> Const m a -> g () Source # ctraverse_ :: (Applicative g, Dom (Const m) a) => (a -> g b) -> Const m a -> g () Source # clast :: Dom (Const m) a => Const m a -> a Source # chead :: Dom (Const m) a => Const m a -> a Source # cfind :: Dom (Const m) a => (a -> Bool) -> Const m a -> Maybe a Source # cfindIndex :: Dom (Const m) a => (a -> Bool) -> Const m a -> Maybe Int Source # cfindIndices :: Dom (Const m) a => (a -> Bool) -> Const m a -> [Int] Source # celemIndex :: (Dom (Const m) a, Eq a) => a -> Const m a -> Maybe Int Source # celemIndices :: (Dom (Const m) a, Eq a) => a -> Const m a -> [Int] Source # | |
CFoldable f => CFoldable (Ap f) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Ap f) a, Monoid w) => (a -> w) -> Ap f a -> w Source # cfoldMap' :: (Dom (Ap f) a, Monoid m) => (a -> m) -> Ap f a -> m Source # cfold :: (Dom (Ap f) w, Monoid w) => Ap f w -> w Source # cfoldr :: Dom (Ap f) a => (a -> b -> b) -> b -> Ap f a -> b Source # cfoldlM :: (Monad m, Dom (Ap f) b) => (a -> b -> m a) -> a -> Ap f b -> m a Source # cfoldlM' :: (Monad m, Dom (Ap f) b) => (a -> b -> m a) -> a -> Ap f b -> m a Source # cfoldrM :: (Monad m, Dom (Ap f) a) => (a -> b -> m b) -> b -> Ap f a -> m b Source # cfoldrM' :: (Monad m, Dom (Ap f) a) => (a -> b -> m b) -> b -> Ap f a -> m b Source # cfoldl :: Dom (Ap f) a => (b -> a -> b) -> b -> Ap f a -> b Source # cfoldr' :: Dom (Ap f) a => (a -> b -> b) -> b -> Ap f a -> b Source # cfoldl' :: Dom (Ap f) a => (b -> a -> b) -> b -> Ap f a -> b Source # cbasicToList :: Dom (Ap f) a => Ap f a -> [a] Source # cfoldr1 :: Dom (Ap f) a => (a -> a -> a) -> Ap f a -> a Source # cfoldl1 :: Dom (Ap f) a => (a -> a -> a) -> Ap f a -> a Source # cindex :: Dom (Ap f) a => Ap f a -> Int -> a Source # cnull :: Dom (Ap f) a => Ap f a -> Bool Source # clength :: Dom (Ap f) a => Ap f a -> Int Source # cany :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> Bool Source # call :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> Bool Source # celem :: (Eq a, Dom (Ap f) a) => a -> Ap f a -> Bool Source # cnotElem :: (Eq a, Dom (Ap f) a) => a -> Ap f a -> Bool Source # cminimum :: (Ord a, Dom (Ap f) a) => Ap f a -> a Source # cmaximum :: (Ord a, Dom (Ap f) a) => Ap f a -> a Source # csum :: (Num a, Dom (Ap f) a) => Ap f a -> a Source # cproduct :: (Num a, Dom (Ap f) a) => Ap f a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Ap f) a, Dom g b) => (a -> g b) -> Ap f a -> g () Source # ctraverse_ :: (Applicative g, Dom (Ap f) a) => (a -> g b) -> Ap f a -> g () Source # clast :: Dom (Ap f) a => Ap f a -> a Source # chead :: Dom (Ap f) a => Ap f a -> a Source # cfind :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> Maybe a Source # cfindIndex :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> Maybe Int Source # cfindIndices :: Dom (Ap f) a => (a -> Bool) -> Ap f a -> [Int] Source # celemIndex :: (Dom (Ap f) a, Eq a) => a -> Ap f a -> Maybe Int Source # celemIndices :: (Dom (Ap f) a, Eq a) => a -> Ap f a -> [Int] Source # | |
CFoldable f => CFoldable (Alt f) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Alt f) a, Monoid w) => (a -> w) -> Alt f a -> w Source # cfoldMap' :: (Dom (Alt f) a, Monoid m) => (a -> m) -> Alt f a -> m Source # cfold :: (Dom (Alt f) w, Monoid w) => Alt f w -> w Source # cfoldr :: Dom (Alt f) a => (a -> b -> b) -> b -> Alt f a -> b Source # cfoldlM :: (Monad m, Dom (Alt f) b) => (a -> b -> m a) -> a -> Alt f b -> m a Source # cfoldlM' :: (Monad m, Dom (Alt f) b) => (a -> b -> m a) -> a -> Alt f b -> m a Source # cfoldrM :: (Monad m, Dom (Alt f) a) => (a -> b -> m b) -> b -> Alt f a -> m b Source # cfoldrM' :: (Monad m, Dom (Alt f) a) => (a -> b -> m b) -> b -> Alt f a -> m b Source # cfoldl :: Dom (Alt f) a => (b -> a -> b) -> b -> Alt f a -> b Source # cfoldr' :: Dom (Alt f) a => (a -> b -> b) -> b -> Alt f a -> b Source # cfoldl' :: Dom (Alt f) a => (b -> a -> b) -> b -> Alt f a -> b Source # cbasicToList :: Dom (Alt f) a => Alt f a -> [a] Source # cfoldr1 :: Dom (Alt f) a => (a -> a -> a) -> Alt f a -> a Source # cfoldl1 :: Dom (Alt f) a => (a -> a -> a) -> Alt f a -> a Source # cindex :: Dom (Alt f) a => Alt f a -> Int -> a Source # cnull :: Dom (Alt f) a => Alt f a -> Bool Source # clength :: Dom (Alt f) a => Alt f a -> Int Source # cany :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> Bool Source # call :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> Bool Source # celem :: (Eq a, Dom (Alt f) a) => a -> Alt f a -> Bool Source # cnotElem :: (Eq a, Dom (Alt f) a) => a -> Alt f a -> Bool Source # cminimum :: (Ord a, Dom (Alt f) a) => Alt f a -> a Source # cmaximum :: (Ord a, Dom (Alt f) a) => Alt f a -> a Source # csum :: (Num a, Dom (Alt f) a) => Alt f a -> a Source # cproduct :: (Num a, Dom (Alt f) a) => Alt f a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (Alt f) a, Dom g b) => (a -> g b) -> Alt f a -> g () Source # ctraverse_ :: (Applicative g, Dom (Alt f) a) => (a -> g b) -> Alt f a -> g () Source # clast :: Dom (Alt f) a => Alt f a -> a Source # chead :: Dom (Alt f) a => Alt f a -> a Source # cfind :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> Maybe a Source # cfindIndex :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> Maybe Int Source # cfindIndices :: Dom (Alt f) a => (a -> Bool) -> Alt f a -> [Int] Source # celemIndex :: (Dom (Alt f) a, Eq a) => a -> Alt f a -> Maybe Int Source # celemIndices :: (Dom (Alt f) a, Eq a) => a -> Alt f a -> [Int] Source # | |
MonoFoldable mono => CFoldable (WrapMono mono :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (WrapMono mono) a, Monoid w) => (a -> w) -> WrapMono mono a -> w Source # cfoldMap' :: (Dom (WrapMono mono) a, Monoid m) => (a -> m) -> WrapMono mono a -> m Source # cfold :: (Dom (WrapMono mono) w, Monoid w) => WrapMono mono w -> w Source # cfoldr :: Dom (WrapMono mono) a => (a -> b -> b) -> b -> WrapMono mono a -> b Source # cfoldlM :: (Monad m, Dom (WrapMono mono) b) => (a -> b -> m a) -> a -> WrapMono mono b -> m a Source # cfoldlM' :: (Monad m, Dom (WrapMono mono) b) => (a -> b -> m a) -> a -> WrapMono mono b -> m a Source # cfoldrM :: (Monad m, Dom (WrapMono mono) a) => (a -> b -> m b) -> b -> WrapMono mono a -> m b Source # cfoldrM' :: (Monad m, Dom (WrapMono mono) a) => (a -> b -> m b) -> b -> WrapMono mono a -> m b Source # cfoldl :: Dom (WrapMono mono) a => (b -> a -> b) -> b -> WrapMono mono a -> b Source # cfoldr' :: Dom (WrapMono mono) a => (a -> b -> b) -> b -> WrapMono mono a -> b Source # cfoldl' :: Dom (WrapMono mono) a => (b -> a -> b) -> b -> WrapMono mono a -> b Source # cbasicToList :: Dom (WrapMono mono) a => WrapMono mono a -> [a] Source # cfoldr1 :: Dom (WrapMono mono) a => (a -> a -> a) -> WrapMono mono a -> a Source # cfoldl1 :: Dom (WrapMono mono) a => (a -> a -> a) -> WrapMono mono a -> a Source # cindex :: Dom (WrapMono mono) a => WrapMono mono a -> Int -> a Source # cnull :: Dom (WrapMono mono) a => WrapMono mono a -> Bool Source # clength :: Dom (WrapMono mono) a => WrapMono mono a -> Int Source # cany :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> Bool Source # call :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> Bool Source # celem :: (Eq a, Dom (WrapMono mono) a) => a -> WrapMono mono a -> Bool Source # cnotElem :: (Eq a, Dom (WrapMono mono) a) => a -> WrapMono mono a -> Bool Source # cminimum :: (Ord a, Dom (WrapMono mono) a) => WrapMono mono a -> a Source # cmaximum :: (Ord a, Dom (WrapMono mono) a) => WrapMono mono a -> a Source # csum :: (Num a, Dom (WrapMono mono) a) => WrapMono mono a -> a Source # cproduct :: (Num a, Dom (WrapMono mono) a) => WrapMono mono a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (WrapMono mono) a, Dom g b) => (a -> g b) -> WrapMono mono a -> g () Source # ctraverse_ :: (Applicative g, Dom (WrapMono mono) a) => (a -> g b) -> WrapMono mono a -> g () Source # clast :: Dom (WrapMono mono) a => WrapMono mono a -> a Source # chead :: Dom (WrapMono mono) a => WrapMono mono a -> a Source # cfind :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> Maybe a Source # cfindIndex :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> Maybe Int Source # cfindIndices :: Dom (WrapMono mono) a => (a -> Bool) -> WrapMono mono a -> [Int] Source # celemIndex :: (Dom (WrapMono mono) a, Eq a) => a -> WrapMono mono a -> Maybe Int Source # celemIndices :: (Dom (WrapMono mono) a, Eq a) => a -> WrapMono mono a -> [Int] Source # | |
CFoldable (K1 i c :: Type -> Type) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (K1 i c) a, Monoid w) => (a -> w) -> K1 i c a -> w Source # cfoldMap' :: (Dom (K1 i c) a, Monoid m) => (a -> m) -> K1 i c a -> m Source # cfold :: (Dom (K1 i c) w, Monoid w) => K1 i c w -> w Source # cfoldr :: Dom (K1 i c) a => (a -> b -> b) -> b -> K1 i c a -> b Source # cfoldlM :: (Monad m, Dom (K1 i c) b) => (a -> b -> m a) -> a -> K1 i c b -> m a Source # cfoldlM' :: (Monad m, Dom (K1 i c) b) => (a -> b -> m a) -> a -> K1 i c b -> m a Source # cfoldrM :: (Monad m, Dom (K1 i c) a) => (a -> b -> m b) -> b -> K1 i c a -> m b Source # cfoldrM' :: (Monad m, Dom (K1 i c) a) => (a -> b -> m b) -> b -> K1 i c a -> m b Source # cfoldl :: Dom (K1 i c) a => (b -> a -> b) -> b -> K1 i c a -> b Source # cfoldr' :: Dom (K1 i c) a => (a -> b -> b) -> b -> K1 i c a -> b Source # cfoldl' :: Dom (K1 i c) a => (b -> a -> b) -> b -> K1 i c a -> b Source # cbasicToList :: Dom (K1 i c) a => K1 i c a -> [a] Source # cfoldr1 :: Dom (K1 i c) a => (a -> a -> a) -> K1 i c a -> a Source # cfoldl1 :: Dom (K1 i c) a => (a -> a -> a) -> K1 i c a -> a Source # cindex :: Dom (K1 i c) a => K1 i c a -> Int -> a Source # cnull :: Dom (K1 i c) a => K1 i c a -> Bool Source # clength :: Dom (K1 i c) a => K1 i c a -> Int Source # cany :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> Bool Source # call :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> Bool Source # celem :: (Eq a, Dom (K1 i c) a) => a -> K1 i c a -> Bool Source # cnotElem :: (Eq a, Dom (K1 i c) a) => a -> K1 i c a -> Bool Source # cminimum :: (Ord a, Dom (K1 i c) a) => K1 i c a -> a Source # cmaximum :: (Ord a, Dom (K1 i c) a) => K1 i c a -> a Source # csum :: (Num a, Dom (K1 i c) a) => K1 i c a -> a Source # cproduct :: (Num a, Dom (K1 i c) a) => K1 i c a -> a Source # cctraverse_ :: (CApplicative g, CPointed g, Dom g (), Dom (K1 i c) a, Dom g b) => (a -> g b) -> K1 i c a -> g () Source # ctraverse_ :: (Applicative g, Dom (K1 i c) a) => (a -> g b) -> K1 i c a -> g () Source # clast :: Dom (K1 i c) a => K1 i c a -> a Source # chead :: Dom (K1 i c) a => K1 i c a -> a Source # cfind :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> Maybe a Source # cfindIndex :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> Maybe Int Source # cfindIndices :: Dom (K1 i c) a => (a -> Bool) -> K1 i c a -> [Int] Source # celemIndex :: (Dom (K1 i c) a, Eq a) => a -> K1 i c a -> Maybe Int Source # celemIndices :: (Dom (K1 i c) a, Eq a) => a -> K1 i c a -> [Int] Source # | |
(CFoldable f, CFoldable g) => CFoldable (f :+: g) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (f :+: g) a, Monoid w) => (a -> w) -> (f :+: g) a -> w Source # cfoldMap' :: (Dom (f :+: g) a, Monoid m) => (a -> m) -> (f :+: g) a -> m Source # cfold :: (Dom (f :+: g) w, Monoid w) => (f :+: g) w -> w Source # cfoldr :: Dom (f :+: g) a => (a -> b -> b) -> b -> (f :+: g) a -> b Source # cfoldlM :: (Monad m, Dom (f :+: g) b) => (a -> b -> m a) -> a -> (f :+: g) b -> m a Source # cfoldlM' :: (Monad m, Dom (f :+: g) b) => (a -> b -> m a) -> a -> (f :+: g) b -> m a Source # cfoldrM :: (Monad m, Dom (f :+: g) a) => (a -> b -> m b) -> b -> (f :+: g) a -> m b Source # cfoldrM' :: (Monad m, Dom (f :+: g) a) => (a -> b -> m b) -> b -> (f :+: g) a -> m b Source # cfoldl :: Dom (f :+: g) a => (b -> a -> b) -> b -> (f :+: g) a -> b Source # cfoldr' :: Dom (f :+: g) a => (a -> b -> b) -> b -> (f :+: g) a -> b Source # cfoldl' :: Dom (f :+: g) a => (b -> a -> b) -> b -> (f :+: g) a -> b Source # cbasicToList :: Dom (f :+: g) a => (f :+: g) a -> [a] Source # cfoldr1 :: Dom (f :+: g) a => (a -> a -> a) -> (f :+: g) a -> a Source # cfoldl1 :: Dom (f :+: g) a => (a -> a -> a) -> (f :+: g) a -> a Source # cindex :: Dom (f :+: g) a => (f :+: g) a -> Int -> a Source # cnull :: Dom (f :+: g) a => (f :+: g) a -> Bool Source # clength :: Dom (f :+: g) a => (f :+: g) a -> Int Source # cany :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> Bool Source # call :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> Bool Source # celem :: (Eq a, Dom (f :+: g) a) => a -> (f :+: g) a -> Bool Source # cnotElem :: (Eq a, Dom (f :+: g) a) => a -> (f :+: g) a -> Bool Source # cminimum :: (Ord a, Dom (f :+: g) a) => (f :+: g) a -> a Source # cmaximum :: (Ord a, Dom (f :+: g) a) => (f :+: g) a -> a Source # csum :: (Num a, Dom (f :+: g) a) => (f :+: g) a -> a Source # cproduct :: (Num a, Dom (f :+: g) a) => (f :+: g) a -> a Source # cctraverse_ :: (CApplicative g0, CPointed g0, Dom g0 (), Dom (f :+: g) a, Dom g0 b) => (a -> g0 b) -> (f :+: g) a -> g0 () Source # ctraverse_ :: (Applicative g0, Dom (f :+: g) a) => (a -> g0 b) -> (f :+: g) a -> g0 () Source # clast :: Dom (f :+: g) a => (f :+: g) a -> a Source # chead :: Dom (f :+: g) a => (f :+: g) a -> a Source # cfind :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> Maybe a Source # cfindIndex :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> Maybe Int Source # cfindIndices :: Dom (f :+: g) a => (a -> Bool) -> (f :+: g) a -> [Int] Source # celemIndex :: (Dom (f :+: g) a, Eq a) => a -> (f :+: g) a -> Maybe Int Source # celemIndices :: (Dom (f :+: g) a, Eq a) => a -> (f :+: g) a -> [Int] Source # | |
(CFoldable f, CFoldable g) => CFoldable (f :*: g) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (f :*: g) a, Monoid w) => (a -> w) -> (f :*: g) a -> w Source # cfoldMap' :: (Dom (f :*: g) a, Monoid m) => (a -> m) -> (f :*: g) a -> m Source # cfold :: (Dom (f :*: g) w, Monoid w) => (f :*: g) w -> w Source # cfoldr :: Dom (f :*: g) a => (a -> b -> b) -> b -> (f :*: g) a -> b Source # cfoldlM :: (Monad m, Dom (f :*: g) b) => (a -> b -> m a) -> a -> (f :*: g) b -> m a Source # cfoldlM' :: (Monad m, Dom (f :*: g) b) => (a -> b -> m a) -> a -> (f :*: g) b -> m a Source # cfoldrM :: (Monad m, Dom (f :*: g) a) => (a -> b -> m b) -> b -> (f :*: g) a -> m b Source # cfoldrM' :: (Monad m, Dom (f :*: g) a) => (a -> b -> m b) -> b -> (f :*: g) a -> m b Source # cfoldl :: Dom (f :*: g) a => (b -> a -> b) -> b -> (f :*: g) a -> b Source # cfoldr' :: Dom (f :*: g) a => (a -> b -> b) -> b -> (f :*: g) a -> b Source # cfoldl' :: Dom (f :*: g) a => (b -> a -> b) -> b -> (f :*: g) a -> b Source # cbasicToList :: Dom (f :*: g) a => (f :*: g) a -> [a] Source # cfoldr1 :: Dom (f :*: g) a => (a -> a -> a) -> (f :*: g) a -> a Source # cfoldl1 :: Dom (f :*: g) a => (a -> a -> a) -> (f :*: g) a -> a Source # cindex :: Dom (f :*: g) a => (f :*: g) a -> Int -> a Source # cnull :: Dom (f :*: g) a => (f :*: g) a -> Bool Source # clength :: Dom (f :*: g) a => (f :*: g) a -> Int Source # cany :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> Bool Source # call :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> Bool Source # celem :: (Eq a, Dom (f :*: g) a) => a -> (f :*: g) a -> Bool Source # cnotElem :: (Eq a, Dom (f :*: g) a) => a -> (f :*: g) a -> Bool Source # cminimum :: (Ord a, Dom (f :*: g) a) => (f :*: g) a -> a Source # cmaximum :: (Ord a, Dom (f :*: g) a) => (f :*: g) a -> a Source # csum :: (Num a, Dom (f :*: g) a) => (f :*: g) a -> a Source # cproduct :: (Num a, Dom (f :*: g) a) => (f :*: g) a -> a Source # cctraverse_ :: (CApplicative g0, CPointed g0, Dom g0 (), Dom (f :*: g) a, Dom g0 b) => (a -> g0 b) -> (f :*: g) a -> g0 () Source # ctraverse_ :: (Applicative g0, Dom (f :*: g) a) => (a -> g0 b) -> (f :*: g) a -> g0 () Source # clast :: Dom (f :*: g) a => (f :*: g) a -> a Source # chead :: Dom (f :*: g) a => (f :*: g) a -> a Source # cfind :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> Maybe a Source # cfindIndex :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> Maybe Int Source # cfindIndices :: Dom (f :*: g) a => (a -> Bool) -> (f :*: g) a -> [Int] Source # celemIndex :: (Dom (f :*: g) a, Eq a) => a -> (f :*: g) a -> Maybe Int Source # celemIndices :: (Dom (f :*: g) a, Eq a) => a -> (f :*: g) a -> [Int] Source # | |
(CFoldable f, CFoldable g) => CFoldable (Product f g) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Product f g) a, Monoid w) => (a -> w) -> Product f g a -> w Source # cfoldMap' :: (Dom (Product f g) a, Monoid m) => (a -> m) -> Product f g a -> m Source # cfold :: (Dom (Product f g) w, Monoid w) => Product f g w -> w Source # cfoldr :: Dom (Product f g) a => (a -> b -> b) -> b -> Product f g a -> b Source # cfoldlM :: (Monad m, Dom (Product f g) b) => (a -> b -> m a) -> a -> Product f g b -> m a Source # cfoldlM' :: (Monad m, Dom (Product f g) b) => (a -> b -> m a) -> a -> Product f g b -> m a Source # cfoldrM :: (Monad m, Dom (Product f g) a) => (a -> b -> m b) -> b -> Product f g a -> m b Source # cfoldrM' :: (Monad m, Dom (Product f g) a) => (a -> b -> m b) -> b -> Product f g a -> m b Source # cfoldl :: Dom (Product f g) a => (b -> a -> b) -> b -> Product f g a -> b Source # cfoldr' :: Dom (Product f g) a => (a -> b -> b) -> b -> Product f g a -> b Source # cfoldl' :: Dom (Product f g) a => (b -> a -> b) -> b -> Product f g a -> b Source # cbasicToList :: Dom (Product f g) a => Product f g a -> [a] Source # cfoldr1 :: Dom (Product f g) a => (a -> a -> a) -> Product f g a -> a Source # cfoldl1 :: Dom (Product f g) a => (a -> a -> a) -> Product f g a -> a Source # cindex :: Dom (Product f g) a => Product f g a -> Int -> a Source # cnull :: Dom (Product f g) a => Product f g a -> Bool Source # clength :: Dom (Product f g) a => Product f g a -> Int Source # cany :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> Bool Source # call :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> Bool Source # celem :: (Eq a, Dom (Product f g) a) => a -> Product f g a -> Bool Source # cnotElem :: (Eq a, Dom (Product f g) a) => a -> Product f g a -> Bool Source # cminimum :: (Ord a, Dom (Product f g) a) => Product f g a -> a Source # cmaximum :: (Ord a, Dom (Product f g) a) => Product f g a -> a Source # csum :: (Num a, Dom (Product f g) a) => Product f g a -> a Source # cproduct :: (Num a, Dom (Product f g) a) => Product f g a -> a Source # cctraverse_ :: (CApplicative g0, CPointed g0, Dom g0 (), Dom (Product f g) a, Dom g0 b) => (a -> g0 b) -> Product f g a -> g0 () Source # ctraverse_ :: (Applicative g0, Dom (Product f g) a) => (a -> g0 b) -> Product f g a -> g0 () Source # clast :: Dom (Product f g) a => Product f g a -> a Source # chead :: Dom (Product f g) a => Product f g a -> a Source # cfind :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> Maybe a Source # cfindIndex :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> Maybe Int Source # cfindIndices :: Dom (Product f g) a => (a -> Bool) -> Product f g a -> [Int] Source # celemIndex :: (Dom (Product f g) a, Eq a) => a -> Product f g a -> Maybe Int Source # celemIndices :: (Dom (Product f g) a, Eq a) => a -> Product f g a -> [Int] Source # | |
(CFoldable f, CFoldable g) => CFoldable (Sum f g) Source # | |
Defined in Control.Subcategory.Foldable cfoldMap :: (Dom (Sum f g) a, Monoid w) => (a -> w) -> Sum f g a -> w Source # cfoldMap' :: (Dom (Sum f g) a, Monoid m) => (a -> m) -> Sum f g a -> m Source # cfold :: (Dom (Sum f g) w, Monoid w) => Sum f g w -> w Source # cfoldr :: Dom (Sum f g) a => (a -> b -> b) -> b -> Sum f g a -> b Source # cfoldlM :: (Monad m, Dom (Sum f g) b) => (a -> b -> m a) -> a -> Sum f g b -> m a Source # cfoldlM' :: (Monad m, Dom (Sum f g) b) => (a -> b -> m a) -> a -> Sum f g b -> m a Source # cfoldrM :: (Monad m, Dom (Sum f g) a) => (a -> b -> m b) -> b -> Sum f g a -> m b Source # cfoldrM' :: (Monad m, Dom (Sum f g) a) => (a -> b -> m b) -> b -> Sum f g a -> m b Source # cfoldl :: Dom (Sum f g) a => (b -> a -> b) -> b -> Sum f g a -> b Source # cfoldr' :: Dom (Sum f g) a => (a -> b -> b) -> b -> Sum f g a -> b Source # cfoldl' :: Dom (Sum f g) a => (b -> a -> b) -> b -> Sum f g a -> b Source # cbasicToList :: Dom (Sum f g) a => Sum f g a -> [a] Source # cfoldr1 :: Dom (Sum f g) a => (a -> a -> a) -> Sum f g a -> a Source # cfoldl1 :: Dom (Sum f g) a => (a -> a -> a) -> Sum f g a -> a Source # cindex :: Dom (Sum f g) a => Sum f g a -> Int -> a Source # cnull :: Dom (Sum f g) a => Sum f g a -> Bool Source # clength :: Dom (Sum f g) a => Sum f g a -> Int Source # cany :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Bool Source # call :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Bool Source # celem :: (Eq a, Dom (Sum f g) a) => a -> Sum f g a -> Bool Source # cnotElem :: (Eq a, Dom (Sum f g) a) => a -> Sum f g a -> Bool Source # cminimum :: (Ord a, Dom (Sum f g) a) => Sum f g a -> a Source # cmaximum :: (Ord a, Dom (Sum f g) a) => Sum f g a -> a Source # csum :: (Num a, Dom (Sum f g) a) => Sum f g a -> a Source # cproduct :: (Num a, Dom (Sum f g) a) => Sum f g a -> a Source # cctraverse_ :: (CApplicative g0, CPointed g0, Dom g0 (), Dom (Sum f g) a, Dom g0 b) => (a -> g0 b) -> Sum f g a -> g0 () Source # ctraverse_ :: (Applicative g0, Dom (Sum f g) a) => (a -> g0 b) -> Sum f g a -> g0 () Source # clast :: Dom (Sum f g) a => Sum f g a -> a Source # chead :: Dom (Sum f g) a => Sum f g a -> a Source # cfind :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Maybe a Source # cfindIndex :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Maybe Int Source # cfindIndices :: Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> [Int] Source # celemIndex :: (Dom (Sum f g) a, Eq a) => a -> Sum f g a -> Maybe Int Source # celemIndices :: (Dom (Sum f g) a, Eq a) => a -> Sum f g a -> [Int] Source # |
class (CFunctor f, CFoldable f) => CTraversable f where Source #
ctraverse :: (Dom f a, Dom f b, Applicative g) => (a -> g b) -> f a -> g (f b) Source #
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
class (CFunctor f, forall x. Dom f x => Monoid (f x), CPointed f, CFoldable f) => CFreeMonoid f where Source #
Free monoid functor from fullsubcategory.
It must be a pointed foldable functor with the property
that for any Monoid
w
and f :: a -> w
,
must be a monoid homomorphism and the following
must be hold:cfoldMap
f
cfoldMap
f .cpure
== f
Hence,
cannot be a free monoid functor;Set
s
Nothing
cbasicFromList :: Dom f a => [a] -> f a Source #
ccons :: Dom f a => a -> f a -> f a Source #
csnoc :: Dom f a => f a -> a -> f a Source #
cfromListN :: Dom f a => Int -> [a] -> f a Source #
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 Source #
cdrop :: Dom f a => Int -> f a -> f a Source #
cinit :: Dom f a => f a -> f a Source #
ctail :: Dom f a => f a -> f a Source #
csplitAt :: Dom f a => Int -> f a -> (f a, f a) Source #
creplicate :: Dom f a => Int -> a -> f a Source #
cgenerate :: Dom f a => Int -> (Int -> a) -> f a Source #
cgenerateM :: (Dom f a, Monad m) => Int -> (Int -> m a) -> m (f a) Source #
cgenerateA :: (Dom f a, Applicative g) => Int -> (Int -> g a) -> g (f a) Source #
cuncons :: Dom f a => f a -> Maybe (a, f a) Source #
cunsnoc :: Dom f a => f a -> Maybe (f a, a) Source #
creverse :: Dom f a => f a -> f a Source #
cintersperse :: Dom f a => a -> f a -> f a Source #
cnub :: (Dom f a, Eq a) => f a -> f a Source #
cnubOrd :: (Dom f a, Ord a) => f a -> f a Source #
csort :: (Dom f a, Ord a) => f a -> f a Source #
csortBy :: Dom f a => (a -> a -> Ordering) -> f a -> f a Source #
cinsert :: (Dom f a, Ord a) => a -> f a -> f a Source #
cinsertBy :: Dom f a => (a -> a -> Ordering) -> a -> f a -> f a Source #
ctakeWhile :: Dom f a => (a -> Bool) -> f a -> f a Source #
cdropWhile :: Dom f a => (a -> Bool) -> f a -> f a Source #
cspan :: Dom f a => (a -> Bool) -> f a -> (f a, f a) Source #
cbreak :: Dom f a => (a -> Bool) -> f a -> (f a, f a) Source #
cfilter :: Dom f a => (a -> Bool) -> f a -> f a Source #
cpartition :: Dom f a => (a -> Bool) -> f a -> (f a, f a) Source #
Instances
cfromList :: (CFreeMonoid f, Dom f a) => [a] -> f a Source #
cfolded :: (CFoldable t, Dom t a) => forall f. (Contravariant f, Applicative f) => (a -> f a) -> t a -> f (t a) Source #
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 Source #
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) Source #
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) Source #