{-# LANGUAGE BangPatterns, CPP, DefaultSignatures, DerivingVia, LambdaCase #-}
{-# LANGUAGE OverloadedStrings, QuantifiedConstraints, StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskell, TypeOperators #-}
{-# OPTIONS_GHC -Wno-orphans #-}
module Control.Subcategory.Foldable
( CFoldable(..),
ctoList,
CTraversable(..),
CFreeMonoid(..),
cfromList,
cfolded, cfolding,
cctraverseFreeMonoid,
cctraverseZipFreeMonoid
) where
import Control.Applicative (ZipList, getZipList)
import Control.Arrow (first, second, (***))
import qualified Control.Foldl as L
import Control.Monad (forM)
import Control.Subcategory.Applicative
import Control.Subcategory.Functor
import Control.Subcategory.Pointed
import Control.Subcategory.Wrapper.Internal
import Control.Subcategory.Zip
import Data.Coerce
import Data.Complex (Complex)
import Data.Foldable
import Data.Functor.Const (Const)
import Data.Functor.Contravariant (Contravariant, contramap,
phantom)
import Data.Functor.Identity (Identity)
import qualified Data.Functor.Product as SOP
import qualified Data.Functor.Sum as SOP
import qualified Data.HashMap.Strict as HM
import qualified Data.HashSet as HS
import qualified Data.IntMap.Strict as IM
import qualified Data.IntSet as IS
import Data.Kind (Type)
import Data.List (uncons)
import Data.List (intersperse)
import Data.List (nub)
import qualified Data.List as List
import Data.List.NonEmpty (NonEmpty)
import qualified Data.List.NonEmpty as NE
import qualified Data.Map as M
import Data.Maybe
import Data.Monoid
import qualified Data.Monoid as Mon
import Data.MonoTraversable hiding (WrappedMono,
unwrapMono)
import Data.Ord (Down)
import qualified Data.Primitive.Array as A
import qualified Data.Primitive.PrimArray as PA
import qualified Data.Primitive.SmallArray as SA
import Data.Proxy (Proxy)
import Data.Semigroup (Arg, Max (..), Min (..))
import qualified Data.Semigroup as Sem
import qualified Data.Sequence as Seq
import Data.Sequences (IsSequence (indexEx))
import qualified Data.Sequences as MT
import qualified Data.Set as Set
import qualified Data.Text as T
import qualified Data.Vector as V
import qualified Data.Vector.Algorithms.Intro as AI
import qualified Data.Vector.Primitive as P
import qualified Data.Vector.Storable as S
import qualified Data.Vector.Unboxed as U
import Foreign.Ptr (Ptr)
import qualified GHC.Exts as GHC
import GHC.Generics
import Language.Haskell.TH hiding (Type)
import Language.Haskell.TH.Syntax hiding (Type)
import qualified VectorBuilder.Builder as VB
import qualified VectorBuilder.Vector as VB
(#.) :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c)
#. :: forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
(#.) b -> c
_f = coerce :: forall a b. Coercible a b => a -> b
coerce
{-# INLINE (#.) #-}
ctoList :: (CFoldable f, Dom f a) => f a -> [a]
{-# INLINE [1] ctoList #-}
ctoList :: forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList = forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
cbasicToList
cfromList :: (CFreeMonoid f, Dom f a) => [a] -> f a
{-# INLINE [1] cfromList #-}
cfromList :: forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cbasicFromList
cfolded
:: (CFoldable t, Dom t a)
=> forall f. (Contravariant f, Applicative f) => (a -> f a) -> t a -> f (t a)
{-# INLINE cfolded #-}
cfolded :: forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded = (forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap (forall a b. a -> b -> a
const ()) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_
class Constrained f => CFoldable f where
{-# MINIMAL cfoldMap | cfoldr #-}
cfoldMap :: (Dom f a, Monoid w) => (a -> w) -> f a -> w
{-# INLINE [1] cfoldMap #-}
cfoldMap a -> w
f = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr (forall a. Monoid a => a -> a -> a
mappend forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> w
f) forall a. Monoid a => a
mempty
cfoldMap' :: (Dom f a, Monoid m) => (a -> m) -> f a -> m
{-# INLINE [1] cfoldMap' #-}
cfoldMap' a -> m
f = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (\ m
acc a
a -> m
acc forall a. Semigroup a => a -> a -> a
<> a -> m
f a
a) forall a. Monoid a => a
mempty
cfold :: (Dom f w, Monoid w) => f w -> w
cfold = forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap forall a. a -> a
id
{-# INLINE [1] cfold #-}
cfoldr :: (Dom f a) => (a -> b -> b) -> b -> f a -> b
{-# INLINE [1] cfoldr #-}
cfoldr a -> b -> b
f b
z f a
t = forall a. Endo a -> a -> a
appEndo (forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (forall a. (a -> a) -> Endo a
Endo forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. a -> b -> b
f) f a
t) b
z
cfoldlM
:: (Monad m, Dom f b)
=> (a -> b -> m a) -> a -> f b -> m a
{-# INLINE [1] cfoldlM #-}
cfoldlM a -> b -> m a
f a
z0 f b
xs = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr b -> (a -> m a) -> a -> m a
f' forall (m :: * -> *) a. Monad m => a -> m a
return f b
xs a
z0
where f' :: b -> (a -> m a) -> a -> m a
f' b
x a -> m a
k a
z = a -> b -> m a
f a
z b
x forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> m a
k
cfoldlM'
:: (Monad m, Dom f b)
=> (a -> b -> m a) -> a -> f b -> m a
{-# INLINE [1] cfoldlM' #-}
cfoldlM' a -> b -> m a
f a
z0 f b
xs = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr' b -> (a -> m a) -> a -> m a
f' forall (m :: * -> *) a. Monad m => a -> m a
return f b
xs a
z0
where f' :: b -> (a -> m a) -> a -> m a
f' !b
x a -> m a
k a
z = do
!a
i <- a -> b -> m a
f a
z b
x
a -> m a
k a
i
cfoldrM
:: (Monad m, Dom f a)
=> (a -> b -> m b) -> b -> f a -> m b
{-# INLINE [1] cfoldrM #-}
cfoldrM a -> b -> m b
f b
z0 f a
xs = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl (b -> m b) -> a -> b -> m b
c forall (m :: * -> *) a. Monad m => a -> m a
return f a
xs b
z0
where c :: (b -> m b) -> a -> b -> m b
c b -> m b
k a
x b
z = a -> b -> m b
f a
x b
z forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> m b
k
cfoldrM'
:: (Monad m, Dom f a)
=> (a -> b -> m b) -> b -> f a -> m b
{-# INLINE [1] cfoldrM' #-}
cfoldrM' a -> b -> m b
f b
z0 f a
xs = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (b -> m b) -> a -> b -> m b
c forall (m :: * -> *) a. Monad m => a -> m a
return f a
xs b
z0
where c :: (b -> m b) -> a -> b -> m b
c b -> m b
k !a
x b
z = do
!b
i <- a -> b -> m b
f a
x b
z
b -> m b
k b
i
cfoldl
:: (Dom f a)
=> (b -> a -> b) -> b -> f a -> b
{-# INLINE [1] cfoldl #-}
cfoldl b -> a -> b
f b
z f a
t = forall a. Endo a -> a -> a
appEndo (forall a. Dual a -> a
getDual (forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (forall a. a -> Dual a
Dual forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a) -> Endo a
Endo forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> a -> b
f) f a
t)) b
z
cfoldr' :: (Dom f a) => (a -> b -> b) -> b -> f a -> b
{-# INLINE [1] cfoldr' #-}
cfoldr' a -> b -> b
f b
z0 f a
xs = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl (b -> b) -> a -> b -> b
f' forall a. a -> a
id f a
xs b
z0
where f' :: (b -> b) -> a -> b -> b
f' b -> b
k a
x b
z = b -> b
k forall a b. (a -> b) -> a -> b
$! a -> b -> b
f a
x b
z
cfoldl' :: Dom f a => (b -> a -> b) -> b -> f a -> b
{-# INLINE [1] cfoldl' #-}
cfoldl' b -> a -> b
f b
z0 f a
xs = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> (b -> b) -> b -> b
f' forall a. a -> a
id f a
xs b
z0
where f' :: a -> (b -> b) -> b -> b
f' a
x b -> b
k b
z = b -> b
k forall a b. (a -> b) -> a -> b
$! b -> a -> b
f b
z a
x
cbasicToList :: Dom f a => f a -> [a]
{-# INLINE cbasicToList #-}
cbasicToList = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr (:) []
cfoldr1 :: Dom f a => (a -> a -> a) -> f a -> a
{-# INLINE [1] cfoldr1 #-}
cfoldr1 a -> a -> a
f f a
xs = forall a. a -> Maybe a -> a
fromMaybe (forall a. [Char] -> a
errorWithoutStackTrace [Char]
"cfoldr1: empty structure")
(forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> Maybe a -> Maybe a
mf forall a. Maybe a
Nothing f a
xs)
where
mf :: a -> Maybe a -> Maybe a
mf a
x Maybe a
m = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
case Maybe a
m of
Maybe a
Nothing -> a
x
Just a
y -> a -> a -> a
f a
x a
y
cfoldl1 :: Dom f a => (a -> a -> a) -> f a -> a
{-# INLINE [1] cfoldl1 #-}
cfoldl1 a -> a -> a
f f a
xs = forall a. a -> Maybe a -> a
fromMaybe (forall a. [Char] -> a
errorWithoutStackTrace [Char]
"cfoldl1: empty structure")
(forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl Maybe a -> a -> Maybe a
mf forall a. Maybe a
Nothing f a
xs)
where
mf :: Maybe a -> a -> Maybe a
mf Maybe a
m a
y = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
case Maybe a
m of
Maybe a
Nothing -> a
y
Just a
x -> a -> a -> a
f a
x a
y
cindex :: Dom f a => f a -> Int -> a
cindex f a
xs Int
n = case forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' Eith' Int a -> a -> Eith' Int a
go (forall a b. a -> Eith' a b
Left' Int
0) f a
xs of
Right' a
x -> a
x
Left'{} -> forall a. [Char] -> a
errorWithoutStackTrace forall a b. (a -> b) -> a -> b
$ [Char]
"cindex: index out of bound " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Int
n
where
go :: Eith' Int a -> a -> Eith' Int a
go (Left' Int
i) a
x
| Int
i forall a. Eq a => a -> a -> Bool
== Int
n = forall a b. b -> Eith' a b
Right' a
x
| Bool
otherwise = forall a b. a -> Eith' a b
Left' (Int
i forall a. Num a => a -> a -> a
+ Int
1)
go r :: Eith' Int a
r@Right'{} a
_ = Eith' Int a
r
cnull :: Dom f a => f a -> Bool
cnull = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall a b. a -> b -> a
const Bool
False) Bool
True
clength :: Dom f a => f a -> Int
{-# INLINE [1] clength #-}
clength = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (\Int
c a
_ -> Int
c forall a. Num a => a -> a -> a
+ Int
1) Int
0
cany :: Dom f a => (a -> Bool) -> f a -> Bool
{-# INLINE [1] cany #-}
cany a -> Bool
p = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (\Bool
b -> Bool -> Bool -> Bool
(||) Bool
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
p) Bool
False
call :: Dom f a => (a -> Bool) -> f a -> Bool
{-# INLINE [1] call #-}
call a -> Bool
p = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (\Bool
b -> Bool -> Bool -> Bool
(&&) Bool
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
p) Bool
True
celem :: (Eq a, Dom f a) => a -> f a -> Bool
{-# INLINE [1] celem #-}
celem = forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => a -> a -> Bool
(==)
cnotElem :: (Eq a, Dom f a) => a -> f a -> Bool
{-# INLINE [1] cnotElem #-}
cnotElem = forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => a -> a -> Bool
(/=)
cminimum :: (Ord a, Dom f a) => f a -> a
{-# INLINE [1] cminimum #-}
cminimum =
forall a. Min a -> a
getMin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe (forall a. [Char] -> a
errorWithoutStackTrace [Char]
"minimum: empty structure")
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Min a
Min)
cmaximum :: (Ord a, Dom f a) => f a -> a
{-# INLINE [1] cmaximum #-}
cmaximum =
forall a. Max a -> a
getMax
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe (forall a. [Char] -> a
errorWithoutStackTrace [Char]
"cmaximum: empty structure")
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Max a
Max)
csum :: (Num a, Dom f a) => f a -> a
{-# INLINE [1] csum #-}
csum = forall a. Sum a -> a
getSum forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap forall a. a -> Sum a
Sum
cproduct :: (Num a, Dom f a) => f a -> a
{-# INLINE [1] cproduct #-}
cproduct = forall a. Product a -> a
getProduct forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap forall a. a -> Product a
Product
cctraverse_
:: (CApplicative g, CPointed g, Dom g (), Dom f a, Dom g b)
=> (a -> g b)
-> f a -> g ()
{-# INLINE [1] cctraverse_ #-}
cctraverse_ a -> g b
f = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> g () -> g ()
c (forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure ())
where
{-# INLINE c #-}
c :: a -> g () -> g ()
c a
x g ()
k = a -> g b
f a
x forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b) =>
f a -> f b -> f b
.> g ()
k
ctraverse_
:: (Applicative g, Dom f a)
=> (a -> g b)
-> f a -> g ()
{-# INLINE [1] ctraverse_ #-}
ctraverse_ a -> g b
f = forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> g () -> g ()
c (forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
where
{-# INLINE c #-}
c :: a -> g () -> g ()
c a
x g ()
k = a -> g b
f a
x forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> g ()
k
clast :: Dom f a => f a -> a
{-# INLINE [1] clast #-}
clast = forall a. HasCallStack => Maybe a -> a
fromJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a b. Handler s a -> Fold a b -> s -> b
L.foldOver forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded forall a. Fold a (Maybe a)
L.last
chead :: Dom f a => f a -> a
{-# INLINE [1] chead #-}
chead = forall a. HasCallStack => Maybe a -> a
fromJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a b. Handler s a -> Fold a b -> s -> b
L.foldOver forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded forall a. Fold a (Maybe a)
L.head
cfind :: Dom f a => (a -> Bool) -> f a -> Maybe a
{-# INLINE [1] cfind #-}
cfind = \a -> Bool
p -> forall a. First a -> Maybe a
getFirst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (\a
x -> forall a. Maybe a -> First a
First forall a b. (a -> b) -> a -> b
$ if a -> Bool
p a
x then forall a. a -> Maybe a
Just a
x else forall a. Maybe a
Nothing)
cfindIndex :: Dom f a => (a -> Bool) -> f a -> Maybe Int
{-# INLINE [1] cfindIndex #-}
cfindIndex = forall s a b. Handler s a -> Fold a b -> s -> b
L.foldOver forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> Fold a (Maybe Int)
L.findIndex
cfindIndices :: Dom f a => (a -> Bool) -> f a -> [Int]
{-# INLINE [1] cfindIndices #-}
cfindIndices = \a -> Bool
p -> forall a. (a -> Bool) -> [a] -> [Int]
List.findIndices a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
celemIndex :: (Dom f a, Eq a) => a -> f a -> Maybe Int
{-# INLINE [0] celemIndex #-}
celemIndex = forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Maybe Int
cfindIndex forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => a -> a -> Bool
(==)
celemIndices :: (Dom f a, Eq a) => a -> f a -> [Int]
{-# INLINE [0] celemIndices #-}
celemIndices = forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> [Int]
cfindIndices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => a -> a -> Bool
(==)
data Eith' a b = Left' !a | Right' !b
instance Traversable f => CTraversable (WrapFunctor f) where
ctraverse :: forall a b (g :: * -> *).
(Dom (WrapFunctor f) a, Dom (WrapFunctor f) b, Applicative g) =>
(a -> g b) -> WrapFunctor f a -> g (WrapFunctor f b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
instance Foldable f => CFoldable (WrapFunctor f) where
cfoldMap :: forall a m.
(Dom (WrapFunctor f) a, Monoid m) =>
(a -> m) -> WrapFunctor f a -> m
cfoldMap = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap
{-# INLINE [1] cfoldMap #-}
cfoldMap' :: forall a m.
(Dom (WrapFunctor f) a, Monoid m) =>
(a -> m) -> WrapFunctor f a -> m
cfoldMap' = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap'
{-# INLINE [1] cfoldMap' #-}
cfold :: forall w. (Dom (WrapFunctor f) w, Monoid w) => WrapFunctor f w -> w
cfold = forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold
{-# INLINE [1] cfold #-}
cfoldr :: forall a b.
Dom (WrapFunctor f) a =>
(a -> b -> b) -> b -> WrapFunctor f a -> b
cfoldr = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
{-# INLINE [1] cfoldr #-}
cfoldr' :: forall a b.
Dom (WrapFunctor f) a =>
(a -> b -> b) -> b -> WrapFunctor f a -> b
cfoldr' = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr'
{-# INLINE [1] cfoldr' #-}
cfoldl :: forall a b.
Dom (WrapFunctor f) a =>
(b -> a -> b) -> b -> WrapFunctor f a -> b
cfoldl = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl
{-# INLINE [1] cfoldl #-}
cfoldl' :: forall a b.
Dom (WrapFunctor f) a =>
(b -> a -> b) -> b -> WrapFunctor f a -> b
cfoldl' = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl'
{-# INLINE [1] cfoldl' #-}
cbasicToList :: forall a. Dom (WrapFunctor f) a => WrapFunctor f a -> [a]
cbasicToList = forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
{-# INLINE [1] cbasicToList #-}
cfoldr1 :: forall a.
Dom (WrapFunctor f) a =>
(a -> a -> a) -> WrapFunctor f a -> a
cfoldr1 = forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1
{-# INLINE [1] cfoldr1 #-}
cfoldl1 :: forall a.
Dom (WrapFunctor f) a =>
(a -> a -> a) -> WrapFunctor f a -> a
cfoldl1 = forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1
{-# INLINE [1] cfoldl1 #-}
cfoldlM :: forall (m :: * -> *) b a.
(Monad m, Dom (WrapFunctor f) b) =>
(a -> b -> m a) -> a -> WrapFunctor f b -> m a
cfoldlM = forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM
{-# INLINE [1] cfoldlM #-}
cfoldrM :: forall (m :: * -> *) a b.
(Monad m, Dom (WrapFunctor f) a) =>
(a -> b -> m b) -> b -> WrapFunctor f a -> m b
cfoldrM = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> b -> m b) -> b -> t a -> m b
foldrM
{-# INLINE [1] cfoldrM #-}
cnull :: forall a. Dom (WrapFunctor f) a => WrapFunctor f a -> Bool
cnull = forall (t :: * -> *) a. Foldable t => t a -> Bool
null
{-# INLINE [1] cnull #-}
clength :: forall a. Dom (WrapFunctor f) a => WrapFunctor f a -> Int
clength = forall (t :: * -> *) a. Foldable t => t a -> Int
length
{-# INLINE [1] clength #-}
cany :: forall a.
Dom (WrapFunctor f) a =>
(a -> Bool) -> WrapFunctor f a -> Bool
cany = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any
{-# INLINE [1] cany #-}
call :: forall a.
Dom (WrapFunctor f) a =>
(a -> Bool) -> WrapFunctor f a -> Bool
call = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all
{-# INLINE [1] call #-}
celem :: forall a.
(Eq a, Dom (WrapFunctor f) a) =>
a -> WrapFunctor f a -> Bool
celem = forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem
{-# INLINE [1] celem #-}
cnotElem :: forall a.
(Eq a, Dom (WrapFunctor f) a) =>
a -> WrapFunctor f a -> Bool
cnotElem = forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem
{-# INLINE [1] cnotElem #-}
cminimum :: forall a. (Ord a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a
cminimum = forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum
{-# INLINE [1] cminimum #-}
cmaximum :: forall a. (Ord a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a
cmaximum = forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum
{-# INLINE [1] cmaximum #-}
csum :: forall a. (Num a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a
csum = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum
{-# INLINE [1] csum #-}
cproduct :: forall a. (Num a, Dom (WrapFunctor f) a) => WrapFunctor f a -> a
cproduct = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
product
{-# INLINE [1] cproduct #-}
ctraverse_ :: forall (g :: * -> *) a b.
(Applicative g, Dom (WrapFunctor f) a) =>
(a -> g b) -> WrapFunctor f a -> g ()
ctraverse_ = forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_
{-# INLINE [1] ctraverse_ #-}
cfind :: forall a.
Dom (WrapFunctor f) a =>
(a -> Bool) -> WrapFunctor f a -> Maybe a
cfind = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find
{-# INLINE [1] cfind #-}
cfindIndex :: forall a.
Dom (WrapFunctor f) a =>
(a -> Bool) -> WrapFunctor f a -> Maybe Int
cfindIndex = forall (f :: * -> *) a b. Foldable f => Fold a b -> f a -> b
L.fold forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> Fold a (Maybe Int)
L.findIndex
{-# INLINE [1] cfindIndex #-}
celemIndex :: forall a.
(Dom (WrapFunctor f) a, Eq a) =>
a -> WrapFunctor f a -> Maybe Int
celemIndex = forall (f :: * -> *) a b. Foldable f => Fold a b -> f a -> b
L.fold forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => a -> Fold a (Maybe Int)
L.elemIndex
{-# INLINE [1] celemIndex #-}
{-# RULES
"cfind/List"
cfind = find @[]
"cfindIndex/List"
cfindIndex = List.findIndex
"cfindIndices/List"
cfindIndices = List.findIndices
"celemIndex/List"
celemIndex = List.elemIndex
"celemIndices/List"
celemIndices = List.elemIndices
"cfindIndex/List"
cfindIndex = Seq.findIndexL
"cfindIndices/Seq"
cfindIndices = Seq.findIndicesL
"celemIndex/Seq"
celemIndex = Seq.elemIndexL
"celemIndices/Seq"
celemIndices = Seq.elemIndicesL
#-}
{-# RULES
"cctraverse_/traverse_"
forall (f :: Applicative f => a -> f b) (tx :: Foldable t => t a).
cctraverse_ f tx = traverse_ f tx
#-}
{-# RULES
"cindex/List"
cindex = (!!)
#-}
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)
deriving via WrapFunctor []
instance CFoldable []
{-# RULES
"ctoList/List"
ctoList = id
"cfromList/List"
cbasicFromList = id
"clast/List"
clast = last
"chead/List"
chead = head
#-}
instance CTraversable [] where
ctraverse :: forall a b (g :: * -> *).
(Dom [] a, Dom [] b, Applicative g) =>
(a -> g b) -> [a] -> g [b]
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Maybe
instance CFoldable Maybe
instance CTraversable Maybe where
ctraverse :: forall a b (g :: * -> *).
(Dom Maybe a, Dom Maybe b, Applicative g) =>
(a -> g b) -> Maybe a -> g (Maybe b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
deriving via WrapFunctor (Either e)
instance CFoldable (Either e)
instance CTraversable (Either e) where
ctraverse :: forall a b (g :: * -> *).
(Dom (Either e) a, Dom (Either e) b, Applicative g) =>
(a -> g b) -> Either e a -> g (Either e b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor IM.IntMap
instance CFoldable IM.IntMap
instance CTraversable IM.IntMap where
ctraverse :: forall a b (g :: * -> *).
(Dom IntMap a, Dom IntMap b, Applicative g) =>
(a -> g b) -> IntMap a -> g (IntMap b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (M.Map k)
instance CFoldable (M.Map k)
instance Ord k => CTraversable (M.Map k) where
ctraverse :: forall a b (g :: * -> *).
(Dom (Map k) a, Dom (Map k) b, Applicative g) =>
(a -> g b) -> Map k a -> g (Map k b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (HM.HashMap k)
instance CFoldable (HM.HashMap k)
instance CTraversable (HM.HashMap k) where
ctraverse :: forall a b (g :: * -> *).
(Dom (HashMap k) a, Dom (HashMap k) b, Applicative g) =>
(a -> g b) -> HashMap k a -> g (HashMap k b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Seq.Seq
instance CFoldable Seq.Seq
instance CTraversable Seq.Seq where
ctraverse :: forall a b (g :: * -> *).
(Dom Seq a, Dom Seq b, Applicative g) =>
(a -> g b) -> Seq a -> g (Seq b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
{-# RULES
"cindex/Seq"
cindex = Seq.index
#-}
deriving via WrapFunctor Par1
instance CFoldable Par1
instance CTraversable Par1 where
ctraverse :: forall a b (g :: * -> *).
(Dom Par1 a, Dom Par1 b, Applicative g) =>
(a -> g b) -> Par1 a -> g (Par1 b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor NonEmpty
instance CFoldable NonEmpty
instance CTraversable NonEmpty where
ctraverse :: forall a b (g :: * -> *).
(Dom NonEmpty a, Dom NonEmpty b, Applicative g) =>
(a -> g b) -> NonEmpty a -> g (NonEmpty b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
{-# RULES
"cindex/NonEmpty"
cindex = (NE.!!)
#-}
deriving via WrapFunctor Down
instance CFoldable Down
instance CTraversable Down where
ctraverse :: forall a b (g :: * -> *).
(Dom Down a, Dom Down b, Applicative g) =>
(a -> g b) -> Down a -> g (Down b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Mon.Last
instance CFoldable Mon.Last
instance CTraversable Mon.Last where
ctraverse :: forall a b (g :: * -> *).
(Dom Last a, Dom Last b, Applicative g) =>
(a -> g b) -> Last a -> g (Last b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Mon.First
instance CFoldable Mon.First
instance CTraversable Mon.First where
ctraverse :: forall a b (g :: * -> *).
(Dom First a, Dom First b, Applicative g) =>
(a -> g b) -> First a -> g (First b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Sem.Last
instance CFoldable Sem.Last
instance CTraversable Sem.Last where
ctraverse :: forall a b (g :: * -> *).
(Dom Last a, Dom Last b, Applicative g) =>
(a -> g b) -> Last a -> g (Last b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Sem.First
instance CFoldable Sem.First
instance CTraversable Sem.First where
ctraverse :: forall a b (g :: * -> *).
(Dom First a, Dom First b, Applicative g) =>
(a -> g b) -> First a -> g (First b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Identity
instance CFoldable Identity
instance CTraversable Identity where
ctraverse :: forall a b (g :: * -> *).
(Dom Identity a, Dom Identity b, Applicative g) =>
(a -> g b) -> Identity a -> g (Identity b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor ZipList
instance CFoldable ZipList
instance CTraversable ZipList where
ctraverse :: forall a b (g :: * -> *).
(Dom ZipList a, Dom ZipList b, Applicative g) =>
(a -> g b) -> ZipList a -> g (ZipList b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
{-# RULES
"cindex/ZipList"
cindex = (!!) . getZipList
#-}
#if !MIN_VERSION_base(4,16,0)
deriving via WrapFunctor Sem.Option
instance CFoldable Sem.Option
instance CTraversable Sem.Option where
ctraverse = traverse
{-# INLINE [1] ctraverse #-}
#endif
deriving via WrapFunctor Min
instance CFoldable Min
instance CTraversable Min where
ctraverse :: forall a b (g :: * -> *).
(Dom Min a, Dom Min b, Applicative g) =>
(a -> g b) -> Min a -> g (Min b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Max
instance CFoldable Max
instance CTraversable Max where
ctraverse :: forall a b (g :: * -> *).
(Dom Max a, Dom Max b, Applicative g) =>
(a -> g b) -> Max a -> g (Max b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor Complex
instance CFoldable Complex
instance CTraversable Complex where
ctraverse :: forall a b (g :: * -> *).
(Dom Complex a, Dom Complex b, Applicative g) =>
(a -> g b) -> Complex a -> g (Complex b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (V1 :: Type -> Type)
instance CFoldable (V1 :: Type -> Type)
instance CTraversable (V1 :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom V1 a, Dom V1 b, Applicative g) =>
(a -> g b) -> V1 a -> g (V1 b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (U1 :: Type -> Type)
instance CFoldable (U1 :: Type -> Type)
instance CTraversable (U1 :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom U1 a, Dom U1 b, Applicative g) =>
(a -> g b) -> U1 a -> g (U1 b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor ((,) a)
instance CFoldable ((,) a)
instance CTraversable ((,) a) where
ctraverse :: forall a b (g :: * -> *).
(Dom ((,) a) a, Dom ((,) a) b, Applicative g) =>
(a -> g b) -> (a, a) -> g (a, b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (Proxy :: Type -> Type)
instance CFoldable (Proxy :: Type -> Type)
instance CTraversable (Proxy :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom Proxy a, Dom Proxy b, Applicative g) =>
(a -> g b) -> Proxy a -> g (Proxy b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (Arg a)
instance CFoldable (Arg a)
instance CTraversable (Arg a) where
ctraverse :: forall a b (g :: * -> *).
(Dom (Arg a) a, Dom (Arg a) b, Applicative g) =>
(a -> g b) -> Arg a a -> g (Arg a b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (Rec1 (f :: Type -> Type))
instance Foldable f => CFoldable (Rec1 (f :: Type -> Type))
deriving via WrapFunctor (URec Char :: Type -> Type)
instance CFoldable (URec Char :: Type -> Type)
instance CTraversable (URec Char :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom (URec Char) a, Dom (URec Char) b, Applicative g) =>
(a -> g b) -> URec Char a -> g (URec Char b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (URec Double :: Type -> Type)
instance CFoldable (URec Double :: Type -> Type)
instance CTraversable (URec Double :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom (URec Double) a, Dom (URec Double) b, Applicative g) =>
(a -> g b) -> URec Double a -> g (URec Double b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (URec Float :: Type -> Type)
instance CFoldable (URec Float :: Type -> Type)
instance CTraversable (URec Float :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom (URec Float) a, Dom (URec Float) b, Applicative g) =>
(a -> g b) -> URec Float a -> g (URec Float b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (URec Int :: Type -> Type)
instance CFoldable (URec Int :: Type -> Type)
instance CTraversable (URec Int :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom (URec Int) a, Dom (URec Int) b, Applicative g) =>
(a -> g b) -> URec Int a -> g (URec Int b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (URec Word :: Type -> Type)
instance CFoldable (URec Word :: Type -> Type)
instance CTraversable (URec Word :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom (URec Word) a, Dom (URec Word) b, Applicative g) =>
(a -> g b) -> URec Word a -> g (URec Word b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (URec (Ptr ()) :: Type -> Type)
instance CFoldable (URec (Ptr ()) :: Type -> Type)
instance CTraversable (URec (Ptr ()) :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom (URec (Ptr ())) a, Dom (URec (Ptr ())) b, Applicative g) =>
(a -> g b) -> URec (Ptr ()) a -> g (URec (Ptr ()) b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving newtype
instance CFoldable f => CFoldable (Alt f)
deriving newtype
instance CFoldable f => CFoldable (Ap f)
deriving via WrapFunctor (Const m :: Type -> Type)
instance CFoldable (Const m :: Type -> Type)
instance CTraversable (Const m :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom (Const m) a, Dom (Const m) b, Applicative g) =>
(a -> g b) -> Const m a -> g (Const m b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
deriving via WrapFunctor (K1 i c :: Type -> Type)
instance CFoldable (K1 i c :: Type -> Type)
instance CTraversable (K1 i c :: Type -> Type) where
ctraverse :: forall a b (g :: * -> *).
(Dom (K1 i c) a, Dom (K1 i c) b, Applicative g) =>
(a -> g b) -> K1 i c a -> g (K1 i c b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
instance (CFoldable f, CFoldable g) => CFoldable (f :+: g) where
{-# INLINE [1] cfoldMap #-}
cfoldMap :: forall a m.
(Dom (f :+: g) a, Monoid m) =>
(a -> m) -> (:+:) f g a -> m
cfoldMap a -> w
f = \case
L1 f a
x -> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f f a
x
R1 g a
x -> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f g a
x
{-# INLINE [1] cfoldr #-}
cfoldr :: forall a b.
Dom (f :+: g) a =>
(a -> b -> b) -> b -> (:+:) f g a -> b
cfoldr a -> b -> b
f b
z = \case
L1 f a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> b -> b
f b
z f a
x
R1 g a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> b -> b
f b
z g a
x
cfoldMap' :: forall a m.
(Dom (f :+: g) a, Monoid m) =>
(a -> m) -> (:+:) f g a -> m
cfoldMap' = \a -> m
f -> \case
L1 f a
x -> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f f a
x
R1 g a
x -> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f g a
x
{-# INLINE [1] cfoldMap' #-}
cfold :: forall w. (Dom (f :+: g) w, Monoid w) => (:+:) f g w -> w
cfold = \case
L1 f w
x -> forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold f w
x
R1 g w
x -> forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold g w
x
{-# INLINE [1] cfold #-}
cfoldr' :: forall a b.
Dom (f :+: g) a =>
(a -> b -> b) -> b -> (:+:) f g a -> b
cfoldr' = \a -> b -> b
f b
z -> \case
L1 f a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr' a -> b -> b
f b
z f a
x
R1 g a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr' a -> b -> b
f b
z g a
x
{-# INLINE [1] cfoldr' #-}
cfoldl :: forall a b.
Dom (f :+: g) a =>
(b -> a -> b) -> b -> (:+:) f g a -> b
cfoldl = \b -> a -> b
f b
z -> \case
L1 f a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl b -> a -> b
f b
z f a
x
R1 g a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl b -> a -> b
f b
z g a
x
{-# INLINE [1] cfoldl #-}
cfoldl' :: forall a b.
Dom (f :+: g) a =>
(b -> a -> b) -> b -> (:+:) f g a -> b
cfoldl' = \b -> a -> b
f b
z -> \case
L1 f a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' b -> a -> b
f b
z f a
x
R1 g a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' b -> a -> b
f b
z g a
x
{-# INLINE [1] cfoldl' #-}
cbasicToList :: forall a. Dom (f :+: g) a => (:+:) f g a -> [a]
cbasicToList = \case
L1 f a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList f a
x
R1 g a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList g a
x
{-# INLINE cbasicToList #-}
cfoldr1 :: forall a. Dom (f :+: g) a => (a -> a -> a) -> (:+:) f g a -> a
cfoldr1 = \a -> a -> a
f -> \case
L1 f a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> a -> a) -> f a -> a
cfoldr1 a -> a -> a
f f a
x
R1 g a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> a -> a) -> f a -> a
cfoldr1 a -> a -> a
f g a
x
{-# INLINE [1] cfoldr1 #-}
cfoldl1 :: forall a. Dom (f :+: g) a => (a -> a -> a) -> (:+:) f g a -> a
cfoldl1 = \a -> a -> a
f -> \case
L1 f a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> a -> a) -> f a -> a
cfoldl1 a -> a -> a
f f a
x
R1 g a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> a -> a) -> f a -> a
cfoldl1 a -> a -> a
f g a
x
{-# INLINE [1] cfoldl1 #-}
cnull :: forall a. Dom (f :+: g) a => (:+:) f g a -> Bool
cnull = \case
L1 f a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull f a
x
R1 g a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull g a
x
{-# INLINE [1] cnull #-}
clength :: forall a. Dom (f :+: g) a => (:+:) f g a -> Int
clength = \case
L1 f a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength f a
x
R1 g a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength g a
x
{-# INLINE [1] clength #-}
cany :: forall a. Dom (f :+: g) a => (a -> Bool) -> (:+:) f g a -> Bool
cany = \a -> Bool
f -> \case
L1 f a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f f a
x
R1 g a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f g a
x
{-# INLINE [1] cany #-}
call :: forall a. Dom (f :+: g) a => (a -> Bool) -> (:+:) f g a -> Bool
call = \a -> Bool
f -> \case
L1 f a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f f a
x
R1 g a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f g a
x
{-# INLINE [1] call #-}
celem :: forall a. (Eq a, Dom (f :+: g) a) => a -> (:+:) f g a -> Bool
celem = \a
x -> \case
L1 f a
xs -> forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x f a
xs
R1 g a
xs -> forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x g a
xs
{-# INLINE [1] celem #-}
cminimum :: forall a. (Ord a, Dom (f :+: g) a) => (:+:) f g a -> a
cminimum = \case
L1 f a
xs -> forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cminimum f a
xs
R1 g a
xs -> forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cminimum g a
xs
{-# INLINE [1] cminimum #-}
cmaximum :: forall a. (Ord a, Dom (f :+: g) a) => (:+:) f g a -> a
cmaximum = \case
L1 f a
xs -> forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cmaximum f a
xs
R1 g a
xs -> forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cmaximum g a
xs
{-# INLINE [1] cmaximum #-}
csum :: forall a. (Num a, Dom (f :+: g) a) => (:+:) f g a -> a
csum = \case
L1 f a
xs -> forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum f a
xs
R1 g a
xs -> forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum g a
xs
{-# INLINE [1] csum #-}
cproduct :: forall a. (Num a, Dom (f :+: g) a) => (:+:) f g a -> a
cproduct = \case
L1 f a
xs -> forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct f a
xs
R1 g a
xs -> forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct g a
xs
{-# INLINE [1] cproduct #-}
ctraverse_ :: forall (g :: * -> *) a b.
(Applicative g, Dom (f :+: g) a) =>
(a -> g b) -> (:+:) f g a -> g ()
ctraverse_ a -> g b
f = \case
L1 f a
xs -> forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f f a
xs
R1 g a
xs -> forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f g a
xs
{-# INLINE [1] ctraverse_ #-}
instance (CTraversable f, CTraversable g) => CTraversable (f :+: g) where
ctraverse :: forall a b (g :: * -> *).
(Dom (f :+: g) a, Dom (f :+: g) b, Applicative g) =>
(a -> g b) -> (:+:) f g a -> g ((:+:) f g b)
ctraverse a -> g b
f = \case
L1 f a
xs -> forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b (g :: * -> *).
(CTraversable f, Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (f b)
ctraverse a -> g b
f f a
xs
R1 g a
xs -> forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b (g :: * -> *).
(CTraversable f, Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (f b)
ctraverse a -> g b
f g a
xs
{-# INLINE [1] ctraverse #-}
instance (CFoldable f, CFoldable g) => CFoldable (f :*: g) where
{-# INLINE [1] cfoldMap #-}
cfoldMap :: forall a m.
(Dom (f :*: g) a, Monoid m) =>
(a -> m) -> (:*:) f g a -> m
cfoldMap a -> w
f (f a
l :*: g a
r) = forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f f a
l forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f g a
r
cfoldMap' :: forall a m.
(Dom (f :*: g) a, Monoid m) =>
(a -> m) -> (:*:) f g a -> m
cfoldMap' a -> m
f (f a
l :*: g a
r) = forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f f a
l forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f g a
r
{-# INLINE [1] cfoldMap' #-}
cfold :: forall w. (Dom (f :*: g) w, Monoid w) => (:*:) f g w -> w
cfold (f w
l :*: g w
r) = forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold f w
l forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold g w
r
{-# INLINE [1] cfold #-}
cnull :: forall a. Dom (f :*: g) a => (:*:) f g a -> Bool
cnull (f a
l :*: g a
r) = forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull f a
l Bool -> Bool -> Bool
&& forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull g a
r
{-# INLINE [1] cnull #-}
clength :: forall a. Dom (f :*: g) a => (:*:) f g a -> Int
clength (f a
l :*: g a
r) = forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength f a
l forall a. Num a => a -> a -> a
+ forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength g a
r
{-# INLINE [1] clength #-}
cany :: forall a. Dom (f :*: g) a => (a -> Bool) -> (:*:) f g a -> Bool
cany a -> Bool
f (f a
l :*: g a
r) = forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f f a
l Bool -> Bool -> Bool
|| forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f g a
r
{-# INLINE [1] cany #-}
call :: forall a. Dom (f :*: g) a => (a -> Bool) -> (:*:) f g a -> Bool
call a -> Bool
f (f a
l :*: g a
r) = forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f f a
l Bool -> Bool -> Bool
&& forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f g a
r
{-# INLINE [1] call #-}
celem :: forall a. (Eq a, Dom (f :*: g) a) => a -> (:*:) f g a -> Bool
celem a
x (f a
l :*: g a
r) = forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x f a
l Bool -> Bool -> Bool
|| forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x g a
r
{-# INLINE [1] celem #-}
csum :: forall a. (Num a, Dom (f :*: g) a) => (:*:) f g a -> a
csum (f a
l :*: g a
r) = forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum f a
l forall a. Num a => a -> a -> a
+ forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum g a
r
{-# INLINE [1] csum #-}
cproduct :: forall a. (Num a, Dom (f :*: g) a) => (:*:) f g a -> a
cproduct (f a
l :*: g a
r) = forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct f a
l forall a. Num a => a -> a -> a
* forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct g a
r
{-# INLINE [1] cproduct #-}
ctraverse_ :: forall (g :: * -> *) a b.
(Applicative g, Dom (f :*: g) a) =>
(a -> g b) -> (:*:) f g a -> g ()
ctraverse_ a -> g b
f (f a
l :*: g a
r) = forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f f a
l forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f g a
r
{-# INLINE [1] ctraverse_ #-}
instance (CTraversable f, CTraversable g) => CTraversable (f :*: g) where
ctraverse :: forall a b (g :: * -> *).
(Dom (f :*: g) a, Dom (f :*: g) b, Applicative g) =>
(a -> g b) -> (:*:) f g a -> g ((:*:) f g b)
ctraverse a -> g b
f (f a
l :*: g a
r) =
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b (g :: * -> *).
(CTraversable f, Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (f b)
ctraverse a -> g b
f f a
l forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a b (g :: * -> *).
(CTraversable f, Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (f b)
ctraverse a -> g b
f g a
r
instance (CFoldable f, CFoldable g) => CFoldable (SOP.Sum f g) where
{-# INLINE [1] cfoldMap #-}
cfoldMap :: forall a m.
(Dom (Sum f g) a, Monoid m) =>
(a -> m) -> Sum f g a -> m
cfoldMap a -> w
f = \case
SOP.InL f a
x -> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f f a
x
SOP.InR g a
x -> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f g a
x
{-# INLINE [1] cfoldr #-}
cfoldr :: forall a b. Dom (Sum f g) a => (a -> b -> b) -> b -> Sum f g a -> b
cfoldr a -> b -> b
f b
z = \case
SOP.InL f a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> b -> b
f b
z f a
x
SOP.InR g a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> b -> b
f b
z g a
x
cfoldMap' :: forall a m.
(Dom (Sum f g) a, Monoid m) =>
(a -> m) -> Sum f g a -> m
cfoldMap' = \a -> m
f -> \case
SOP.InL f a
x -> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f f a
x
SOP.InR g a
x -> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f g a
x
{-# INLINE [1] cfoldMap' #-}
cfold :: forall w. (Dom (Sum f g) w, Monoid w) => Sum f g w -> w
cfold = \case
SOP.InL f w
x -> forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold f w
x
SOP.InR g w
x -> forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold g w
x
{-# INLINE [1] cfold #-}
cfoldr' :: forall a b. Dom (Sum f g) a => (a -> b -> b) -> b -> Sum f g a -> b
cfoldr' = \a -> b -> b
f b
z -> \case
SOP.InL f a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr' a -> b -> b
f b
z f a
x
SOP.InR g a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr' a -> b -> b
f b
z g a
x
{-# INLINE [1] cfoldr' #-}
cfoldl :: forall a b. Dom (Sum f g) a => (b -> a -> b) -> b -> Sum f g a -> b
cfoldl = \b -> a -> b
f b
z -> \case
SOP.InL f a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl b -> a -> b
f b
z f a
x
SOP.InR g a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl b -> a -> b
f b
z g a
x
{-# INLINE [1] cfoldl #-}
cfoldl' :: forall a b. Dom (Sum f g) a => (b -> a -> b) -> b -> Sum f g a -> b
cfoldl' = \b -> a -> b
f b
z -> \case
SOP.InL f a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' b -> a -> b
f b
z f a
x
SOP.InR g a
x -> forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' b -> a -> b
f b
z g a
x
{-# INLINE [1] cfoldl' #-}
cbasicToList :: forall a. Dom (Sum f g) a => Sum f g a -> [a]
cbasicToList = \case
SOP.InL f a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList f a
x
SOP.InR g a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList g a
x
{-# INLINE cbasicToList #-}
cfoldr1 :: forall a. Dom (Sum f g) a => (a -> a -> a) -> Sum f g a -> a
cfoldr1 = \a -> a -> a
f -> \case
SOP.InL f a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> a -> a) -> f a -> a
cfoldr1 a -> a -> a
f f a
x
SOP.InR g a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> a -> a) -> f a -> a
cfoldr1 a -> a -> a
f g a
x
{-# INLINE [1] cfoldr1 #-}
cfoldl1 :: forall a. Dom (Sum f g) a => (a -> a -> a) -> Sum f g a -> a
cfoldl1 = \a -> a -> a
f -> \case
SOP.InL f a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> a -> a) -> f a -> a
cfoldl1 a -> a -> a
f f a
x
SOP.InR g a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> a -> a) -> f a -> a
cfoldl1 a -> a -> a
f g a
x
{-# INLINE [1] cfoldl1 #-}
cnull :: forall a. Dom (Sum f g) a => Sum f g a -> Bool
cnull = \case
SOP.InL f a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull f a
x
SOP.InR g a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull g a
x
{-# INLINE [1] cnull #-}
clength :: forall a. Dom (Sum f g) a => Sum f g a -> Int
clength = \case
SOP.InL f a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength f a
x
SOP.InR g a
x -> forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength g a
x
{-# INLINE [1] clength #-}
cany :: forall a. Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Bool
cany = \a -> Bool
f -> \case
SOP.InL f a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f f a
x
SOP.InR g a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f g a
x
{-# INLINE [1] cany #-}
call :: forall a. Dom (Sum f g) a => (a -> Bool) -> Sum f g a -> Bool
call = \a -> Bool
f -> \case
SOP.InL f a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f f a
x
SOP.InR g a
x -> forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f g a
x
{-# INLINE [1] call #-}
celem :: forall a. (Eq a, Dom (Sum f g) a) => a -> Sum f g a -> Bool
celem = \a
x -> \case
SOP.InL f a
xs -> forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x f a
xs
SOP.InR g a
xs -> forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x g a
xs
{-# INLINE [1] celem #-}
cminimum :: forall a. (Ord a, Dom (Sum f g) a) => Sum f g a -> a
cminimum = \case
SOP.InL f a
xs -> forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cminimum f a
xs
SOP.InR g a
xs -> forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cminimum g a
xs
{-# INLINE [1] cminimum #-}
cmaximum :: forall a. (Ord a, Dom (Sum f g) a) => Sum f g a -> a
cmaximum = \case
SOP.InL f a
xs -> forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cmaximum f a
xs
SOP.InR g a
xs -> forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cmaximum g a
xs
{-# INLINE [1] cmaximum #-}
csum :: forall a. (Num a, Dom (Sum f g) a) => Sum f g a -> a
csum = \case
SOP.InL f a
xs -> forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum f a
xs
SOP.InR g a
xs -> forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum g a
xs
{-# INLINE [1] csum #-}
cproduct :: forall a. (Num a, Dom (Sum f g) a) => Sum f g a -> a
cproduct = \case
SOP.InL f a
xs -> forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct f a
xs
SOP.InR g a
xs -> forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct g a
xs
{-# INLINE [1] cproduct #-}
ctraverse_ :: forall (g :: * -> *) a b.
(Applicative g, Dom (Sum f g) a) =>
(a -> g b) -> Sum f g a -> g ()
ctraverse_ a -> g b
f = \case
SOP.InL f a
xs -> forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f f a
xs
SOP.InR g a
xs -> forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f g a
xs
{-# INLINE [1] ctraverse_ #-}
instance (CTraversable f, CTraversable g) => CTraversable (SOP.Sum f g) where
ctraverse :: forall a b (g :: * -> *).
(Dom (Sum f g) a, Dom (Sum f g) b, Applicative g) =>
(a -> g b) -> Sum f g a -> g (Sum f g b)
ctraverse a -> g b
f = \case
SOP.InL f a
xs -> forall {k} (f :: k -> *) (g :: k -> *) (a :: k). f a -> Sum f g a
SOP.InL forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b (g :: * -> *).
(CTraversable f, Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (f b)
ctraverse a -> g b
f f a
xs
SOP.InR g a
xs -> forall {k} (f :: k -> *) (g :: k -> *) (a :: k). g a -> Sum f g a
SOP.InR forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b (g :: * -> *).
(CTraversable f, Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (f b)
ctraverse a -> g b
f g a
xs
{-# INLINE [1] ctraverse #-}
instance (CFoldable f, CFoldable g) => CFoldable (SOP.Product f g) where
{-# INLINE [1] cfoldMap #-}
cfoldMap :: forall a m.
(Dom (Product f g) a, Monoid m) =>
(a -> m) -> Product f g a -> m
cfoldMap a -> w
f (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f f a
l forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f g a
r
cfoldMap' :: forall a m.
(Dom (Product f g) a, Monoid m) =>
(a -> m) -> Product f g a -> m
cfoldMap' a -> m
f (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f f a
l forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f g a
r
{-# INLINE [1] cfoldMap' #-}
cfold :: forall w. (Dom (Product f g) w, Monoid w) => Product f g w -> w
cfold (SOP.Pair f w
l g w
r) = forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold f w
l forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold g w
r
{-# INLINE [1] cfold #-}
cnull :: forall a. Dom (Product f g) a => Product f g a -> Bool
cnull (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull f a
l Bool -> Bool -> Bool
&& forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull g a
r
{-# INLINE [1] cnull #-}
clength :: forall a. Dom (Product f g) a => Product f g a -> Int
clength (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength f a
l forall a. Num a => a -> a -> a
+ forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength g a
r
{-# INLINE [1] clength #-}
cany :: forall a.
Dom (Product f g) a =>
(a -> Bool) -> Product f g a -> Bool
cany a -> Bool
f (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f f a
l Bool -> Bool -> Bool
|| forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f g a
r
{-# INLINE [1] cany #-}
call :: forall a.
Dom (Product f g) a =>
(a -> Bool) -> Product f g a -> Bool
call a -> Bool
f (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f f a
l Bool -> Bool -> Bool
&& forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f g a
r
{-# INLINE [1] call #-}
celem :: forall a. (Eq a, Dom (Product f g) a) => a -> Product f g a -> Bool
celem a
x (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x f a
l Bool -> Bool -> Bool
|| forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x g a
r
{-# INLINE [1] celem #-}
csum :: forall a. (Num a, Dom (Product f g) a) => Product f g a -> a
csum (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum f a
l forall a. Num a => a -> a -> a
+ forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum g a
r
{-# INLINE [1] csum #-}
cproduct :: forall a. (Num a, Dom (Product f g) a) => Product f g a -> a
cproduct (SOP.Pair f a
l g a
r) = forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct f a
l forall a. Num a => a -> a -> a
* forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct g a
r
{-# INLINE [1] cproduct #-}
ctraverse_ :: forall (g :: * -> *) a b.
(Applicative g, Dom (Product f g) a) =>
(a -> g b) -> Product f g a -> g ()
ctraverse_ a -> g b
f (SOP.Pair f a
l g a
r) =
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f f a
l forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f g a
r
{-# INLINE ctraverse_ #-}
deriving via WrapFunctor SA.SmallArray instance CFoldable SA.SmallArray
deriving via WrapFunctor A.Array instance CFoldable A.Array
instance CFoldable PA.PrimArray where
cfoldr :: forall a b.
Dom PrimArray a =>
(a -> b -> b) -> b -> PrimArray a -> b
cfoldr = forall a b. Prim a => (a -> b -> b) -> b -> PrimArray a -> b
PA.foldrPrimArray
{-# INLINE [1] cfoldr #-}
cfoldl' :: forall a b.
Dom PrimArray a =>
(b -> a -> b) -> b -> PrimArray a -> b
cfoldl' = forall a b. Prim a => (b -> a -> b) -> b -> PrimArray a -> b
PA.foldlPrimArray'
{-# INLINE [1] cfoldl' #-}
cfoldlM' :: forall (m :: * -> *) b a.
(Monad m, Dom PrimArray b) =>
(a -> b -> m a) -> a -> PrimArray b -> m a
cfoldlM' = forall a (m :: * -> *) b.
(Prim a, Monad m) =>
(b -> a -> m b) -> b -> PrimArray a -> m b
PA.foldlPrimArrayM'
{-# INLINE [1] cfoldlM' #-}
cfoldl :: forall a b.
Dom PrimArray a =>
(b -> a -> b) -> b -> PrimArray a -> b
cfoldl = forall a b. Prim a => (b -> a -> b) -> b -> PrimArray a -> b
PA.foldlPrimArray
{-# INLINE [1] cfoldl #-}
clength :: forall a. Dom PrimArray a => PrimArray a -> Int
clength = forall a. Prim a => PrimArray a -> Int
PA.sizeofPrimArray
{-# INLINE [1] clength #-}
csum :: forall a. (Num a, Dom PrimArray a) => PrimArray a -> a
csum = forall a b. Prim a => (b -> a -> b) -> b -> PrimArray a -> b
PA.foldlPrimArray' forall a. Num a => a -> a -> a
(+) a
0
{-# INLINE [1] csum #-}
cproduct :: forall a. (Num a, Dom PrimArray a) => PrimArray a -> a
cproduct = forall a b. Prim a => (b -> a -> b) -> b -> PrimArray a -> b
PA.foldlPrimArray' forall a. Num a => a -> a -> a
(*) a
1
{-# INLINE [1] cproduct #-}
ctraverse_ :: forall (g :: * -> *) a b.
(Applicative g, Dom PrimArray a) =>
(a -> g b) -> PrimArray a -> g ()
ctraverse_ = forall (f :: * -> *) a b.
(Applicative f, Prim a) =>
(a -> f b) -> PrimArray a -> f ()
PA.traversePrimArray_
{-# INLINE [1] ctraverse_ #-}
instance CTraversable PA.PrimArray where
ctraverse :: forall a b (g :: * -> *).
(Dom PrimArray a, Dom PrimArray b, Applicative g) =>
(a -> g b) -> PrimArray a -> g (PrimArray b)
ctraverse = forall (f :: * -> *) a b.
(Applicative f, Prim a, Prim b) =>
(a -> f b) -> PrimArray a -> f (PrimArray b)
PA.traversePrimArray
{-# INLINE [1] ctraverse #-}
instance CTraversable SA.SmallArray where
ctraverse :: forall a b (g :: * -> *).
(Dom SmallArray a, Dom SmallArray b, Applicative g) =>
(a -> g b) -> SmallArray a -> g (SmallArray b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
instance CTraversable A.Array where
ctraverse :: forall a b (g :: * -> *).
(Dom Array a, Dom Array b, Applicative g) =>
(a -> g b) -> Array a -> g (Array b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
instance (CTraversable f, CTraversable g) => CTraversable (SOP.Product f g) where
{-# INLINE [1] ctraverse #-}
ctraverse :: forall a b (g :: * -> *).
(Dom (Product f g) a, Dom (Product f g) b, Applicative g) =>
(a -> g b) -> Product f g a -> g (Product f g b)
ctraverse a -> g b
f (SOP.Pair f a
l g a
r) =
forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
SOP.Pair forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b (g :: * -> *).
(CTraversable f, Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (f b)
ctraverse a -> g b
f f a
l forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a b (g :: * -> *).
(CTraversable f, Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (f b)
ctraverse a -> g b
f g a
r
instance CFoldable Set.Set where
cfoldMap :: forall a m. (Dom Set a, Monoid m) => (a -> m) -> Set a -> m
cfoldMap = forall mono m.
(MonoFoldable mono, Monoid m) =>
(Element mono -> m) -> mono -> m
ofoldMap
{-# INLINE [1] cfoldMap #-}
cfoldr :: forall a b. Dom Set a => (a -> b -> b) -> b -> Set a -> b
cfoldr = forall a b. (a -> b -> b) -> b -> Set a -> b
Set.foldr
{-# INLINE [1] cfoldr #-}
cfoldl :: forall a b. Dom Set a => (b -> a -> b) -> b -> Set a -> b
cfoldl = forall a b. (a -> b -> a) -> a -> Set b -> a
Set.foldl
{-# INLINE [1] cfoldl #-}
cfoldr' :: forall a b. Dom Set a => (a -> b -> b) -> b -> Set a -> b
cfoldr' = forall a b. (a -> b -> b) -> b -> Set a -> b
Set.foldr'
{-# INLINE [1] cfoldr' #-}
cfoldl' :: forall a b. Dom Set a => (b -> a -> b) -> b -> Set a -> b
cfoldl' = forall a b. (a -> b -> a) -> a -> Set b -> a
Set.foldl'
{-# INLINE [1] cfoldl' #-}
cminimum :: forall a. (Ord a, Dom Set a) => Set a -> a
cminimum = forall a. Set a -> a
Set.findMin
{-# INLINE [1] cminimum #-}
cmaximum :: forall a. (Ord a, Dom Set a) => Set a -> a
cmaximum = forall a. Set a -> a
Set.findMax
{-# INLINE [1] cmaximum #-}
celem :: forall a. (Eq a, Dom Set a) => a -> Set a -> Bool
celem = forall a. Ord a => a -> Set a -> Bool
Set.member
{-# INLINE [1] celem #-}
cnotElem :: forall a. (Eq a, Dom Set a) => a -> Set a -> Bool
cnotElem = forall a. Ord a => a -> Set a -> Bool
Set.notMember
{-# INLINE [1] cnotElem #-}
cbasicToList :: forall a. Dom Set a => Set a -> [a]
cbasicToList = forall a. Set a -> [a]
Set.toList
{-# INLINE cbasicToList #-}
celemIndex :: forall a. (Dom Set a, Eq a) => a -> Set a -> Maybe Int
celemIndex = forall a. Ord a => a -> Set a -> Maybe Int
Set.lookupIndex
{-# INLINE [1] celemIndex #-}
cindex :: forall a. Dom Set a => Set a -> Int -> a
cindex = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. Int -> Set a -> a
Set.elemAt
{-# INLINE [1] cindex #-}
instance CTraversable Set.Set where
ctraverse :: forall a b (g :: * -> *).
(Dom Set a, Dom Set b, Applicative g) =>
(a -> g b) -> Set a -> g (Set b)
ctraverse a -> g b
f =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Ord a => [a] -> Set a
Set.fromList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> g b
f
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Set a -> [a]
Set.toList
{-# INLINE [1] ctraverse #-}
instance CFoldable HS.HashSet where
cfoldMap :: forall a m. (Dom HashSet a, Monoid m) => (a -> m) -> HashSet a -> m
cfoldMap = forall mono m.
(MonoFoldable mono, Monoid m) =>
(Element mono -> m) -> mono -> m
ofoldMap
{-# INLINE [1] cfoldMap #-}
cfoldr :: forall a b. Dom HashSet a => (a -> b -> b) -> b -> HashSet a -> b
cfoldr = forall b a. (b -> a -> a) -> a -> HashSet b -> a
HS.foldr
{-# INLINE [1] cfoldr #-}
cfoldl' :: forall a b. Dom HashSet a => (b -> a -> b) -> b -> HashSet a -> b
cfoldl' = forall a b. (a -> b -> a) -> a -> HashSet b -> a
HS.foldl'
{-# INLINE [1] cfoldl' #-}
celem :: forall a. (Eq a, Dom HashSet a) => a -> HashSet a -> Bool
celem = forall a. (Eq a, Hashable a) => a -> HashSet a -> Bool
HS.member
{-# INLINE [1] celem #-}
cbasicToList :: forall a. Dom HashSet a => HashSet a -> [a]
cbasicToList = forall a. HashSet a -> [a]
HS.toList
{-# INLINE cbasicToList #-}
instance CTraversable HS.HashSet where
ctraverse :: forall a b (g :: * -> *).
(Dom HashSet a, Dom HashSet b, Applicative g) =>
(a -> g b) -> HashSet a -> g (HashSet b)
ctraverse a -> g b
f =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. (Eq a, Hashable a) => [a] -> HashSet a
HS.fromList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> g b
f
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. HashSet a -> [a]
HS.toList
{-# INLINE [1] ctraverse #-}
{-# RULES
"celem/IntSet"
celem = coerce
@(Int -> IS.IntSet -> Bool)
@(Int -> WrapMono IS.IntSet Int -> Bool)
IS.member
"cnotElem/IntSet"
cnotElem = coerce
@(Int -> IS.IntSet -> Bool)
@(Int -> WrapMono IS.IntSet Int -> Bool)
IS.notMember
"cmaximum/IntSet"
cmaximum = coerce @_ @(WrapMono IS.IntSet Int -> Int)
IS.findMax
"cminimum/IntSet"
cminimum = coerce @(IS.IntSet -> Int) @(WrapMono IS.IntSet Int -> Int)
IS.findMin
#-}
instance MonoFoldable mono => CFoldable (WrapMono mono) where
cfoldMap :: forall a m.
(Dom (WrapMono mono) a, Monoid m) =>
(a -> m) -> WrapMono mono a -> m
cfoldMap = forall mono m.
(MonoFoldable mono, Monoid m) =>
(Element mono -> m) -> mono -> m
ofoldMap
{-# INLINE [1] cfoldMap #-}
cfold :: forall w. (Dom (WrapMono mono) w, Monoid w) => WrapMono mono w -> w
cfold = forall mono.
(MonoFoldable mono, Monoid (Element mono)) =>
mono -> Element mono
ofold
{-# INLINE [1] cfold #-}
cfoldr :: forall a b.
Dom (WrapMono mono) a =>
(a -> b -> b) -> b -> WrapMono mono a -> b
cfoldr = forall mono b.
MonoFoldable mono =>
(Element mono -> b -> b) -> b -> mono -> b
ofoldr
{-# INLINE [1] cfoldr #-}
cfoldl' :: forall a b.
Dom (WrapMono mono) a =>
(b -> a -> b) -> b -> WrapMono mono a -> b
cfoldl' = forall mono a.
MonoFoldable mono =>
(a -> Element mono -> a) -> a -> mono -> a
ofoldl'
{-# INLINE [1] cfoldl' #-}
cfoldlM :: forall (m :: * -> *) b a.
(Monad m, Dom (WrapMono mono) b) =>
(a -> b -> m a) -> a -> WrapMono mono b -> m a
cfoldlM = forall mono (m :: * -> *) a.
(MonoFoldable mono, Monad m) =>
(a -> Element mono -> m a) -> a -> mono -> m a
ofoldlM
{-# INLINE [1] cfoldlM #-}
cbasicToList :: forall a. Dom (WrapMono mono) a => WrapMono mono a -> [a]
cbasicToList = forall mono. MonoFoldable mono => mono -> [Element mono]
otoList
{-# INLINE cbasicToList #-}
cfoldr1 :: forall a.
Dom (WrapMono mono) a =>
(a -> a -> a) -> WrapMono mono a -> a
cfoldr1 = forall mono.
MonoFoldable mono =>
(Element mono -> Element mono -> Element mono)
-> mono -> Element mono
ofoldr1Ex
{-# INLINE [1] cfoldr1 #-}
cnull :: forall a. Dom (WrapMono mono) a => WrapMono mono a -> Bool
cnull = forall mono. MonoFoldable mono => mono -> Bool
onull
{-# INLINE [1] cnull #-}
clength :: forall a. Dom (WrapMono mono) a => WrapMono mono a -> Int
clength = forall mono. MonoFoldable mono => mono -> Int
olength
{-# INLINE [1] clength #-}
cany :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool) -> WrapMono mono a -> Bool
cany = forall mono.
MonoFoldable mono =>
(Element mono -> Bool) -> mono -> Bool
oany
{-# INLINE [1] cany #-}
call :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool) -> WrapMono mono a -> Bool
call = forall mono.
MonoFoldable mono =>
(Element mono -> Bool) -> mono -> Bool
oall
{-# INLINE [1] call #-}
celem :: forall a.
(Eq a, Dom (WrapMono mono) a) =>
a -> WrapMono mono a -> Bool
celem = forall mono.
(MonoFoldable mono, Eq (Element mono)) =>
Element mono -> mono -> Bool
oelem
{-# INLINE [1] celem #-}
cnotElem :: forall a.
(Eq a, Dom (WrapMono mono) a) =>
a -> WrapMono mono a -> Bool
cnotElem = forall mono.
(MonoFoldable mono, Eq (Element mono)) =>
Element mono -> mono -> Bool
onotElem
{-# INLINE [1] cnotElem #-}
cminimum :: forall a. (Ord a, Dom (WrapMono mono) a) => WrapMono mono a -> a
cminimum = forall mono.
(MonoFoldable mono, Ord (Element mono)) =>
mono -> Element mono
minimumEx
{-# INLINE [1] cminimum #-}
cmaximum :: forall a. (Ord a, Dom (WrapMono mono) a) => WrapMono mono a -> a
cmaximum = forall mono.
(MonoFoldable mono, Ord (Element mono)) =>
mono -> Element mono
maximumEx
{-# INLINE [1] cmaximum #-}
csum :: forall a. (Num a, Dom (WrapMono mono) a) => WrapMono mono a -> a
csum = forall mono.
(MonoFoldable mono, Num (Element mono)) =>
mono -> Element mono
osum
{-# INLINE [1] csum #-}
cproduct :: forall a. (Num a, Dom (WrapMono mono) a) => WrapMono mono a -> a
cproduct = forall mono.
(MonoFoldable mono, Num (Element mono)) =>
mono -> Element mono
oproduct
{-# INLINE [1] cproduct #-}
ctraverse_ :: forall (g :: * -> *) a b.
(Applicative g, Dom (WrapMono mono) a) =>
(a -> g b) -> WrapMono mono a -> g ()
ctraverse_ = forall mono (f :: * -> *) b.
(MonoFoldable mono, Applicative f) =>
(Element mono -> f b) -> mono -> f ()
otraverse_
{-# INLINE [1] ctraverse_ #-}
instance MonoTraversable mono => CTraversable (WrapMono mono) where
ctraverse :: forall a b (g :: * -> *).
(Dom (WrapMono mono) a, Dom (WrapMono mono) b, Applicative g) =>
(a -> g b) -> WrapMono mono a -> g (WrapMono mono b)
ctraverse = \a -> g b
f -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall b mono.
(b ~ Element mono, b ~ Element mono) =>
mono -> WrapMono mono b
WrapMono forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall mono (f :: * -> *).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
otraverse a -> g b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b mono. (b ~ Element mono) => WrapMono mono b -> mono
unwrapMono
instance CFoldable V.Vector where
{-# INLINE [1] cfoldMap #-}
cfoldMap :: forall a m. (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m
cfoldMap = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap
{-# INLINE [1] cfoldr #-}
cfoldr :: forall a b. Dom Vector a => (a -> b -> b) -> b -> Vector a -> b
cfoldr = forall a b. (a -> b -> b) -> b -> Vector a -> b
V.foldr
{-# INLINE [1] cfoldr' #-}
cfoldr' :: forall a b. Dom Vector a => (a -> b -> b) -> b -> Vector a -> b
cfoldr' = forall a b. (a -> b -> b) -> b -> Vector a -> b
V.foldr'
{-# INLINE [1] cfoldl #-}
cfoldl :: forall a b. Dom Vector a => (b -> a -> b) -> b -> Vector a -> b
cfoldl = forall a b. (a -> b -> a) -> a -> Vector b -> a
V.foldl
{-# INLINE [1] cfoldl' #-}
cfoldl' :: forall a b. Dom Vector a => (b -> a -> b) -> b -> Vector a -> b
cfoldl' = forall a b. (a -> b -> a) -> a -> Vector b -> a
V.foldl'
{-# INLINE cfoldlM #-}
cfoldlM :: forall (m :: * -> *) b a.
(Monad m, Dom Vector b) =>
(a -> b -> m a) -> a -> Vector b -> m a
cfoldlM = forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m a) -> a -> Vector b -> m a
V.foldM
{-# INLINE cfoldlM' #-}
cfoldlM' :: forall (m :: * -> *) b a.
(Monad m, Dom Vector b) =>
(a -> b -> m a) -> a -> Vector b -> m a
cfoldlM' = forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m a) -> a -> Vector b -> m a
V.foldM'
{-# INLINE [1] cindex #-}
cindex :: forall a. Dom Vector a => Vector a -> Int -> a
cindex = forall a. Vector a -> Int -> a
(V.!)
{-# INLINE [1] celem #-}
celem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
celem = forall a. Eq a => a -> Vector a -> Bool
V.elem
{-# INLINE [1] cnotElem #-}
cnotElem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
cnotElem = forall a. Eq a => a -> Vector a -> Bool
V.notElem
{-# INLINE [1] cany #-}
cany :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
cany = forall a. (a -> Bool) -> Vector a -> Bool
V.any
{-# INLINE [1] call #-}
call :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
call = forall a. (a -> Bool) -> Vector a -> Bool
V.all
{-# INLINE [1] cfoldl1 #-}
cfoldl1 :: forall a. Dom Vector a => (a -> a -> a) -> Vector a -> a
cfoldl1 = forall a. (a -> a -> a) -> Vector a -> a
V.foldl1
{-# INLINE [1] cfoldr1 #-}
cfoldr1 :: forall a. Dom Vector a => (a -> a -> a) -> Vector a -> a
cfoldr1 = forall a. (a -> a -> a) -> Vector a -> a
V.foldr1
{-# INLINE [1] csum #-}
csum :: forall a. (Num a, Dom Vector a) => Vector a -> a
csum = forall a. Num a => Vector a -> a
V.sum
{-# INLINE [1] cproduct #-}
cproduct :: forall a. (Num a, Dom Vector a) => Vector a -> a
cproduct = forall a. Num a => Vector a -> a
V.product
{-# INLINE [1] cmaximum #-}
cmaximum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cmaximum = forall a. Ord a => Vector a -> a
V.maximum
{-# INLINE [1] cminimum #-}
cminimum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cminimum = forall a. Ord a => Vector a -> a
V.minimum
{-# INLINE cbasicToList #-}
cbasicToList :: forall a. Dom Vector a => Vector a -> [a]
cbasicToList = forall a. Vector a -> [a]
V.toList
{-# INLINE [1] clast #-}
clast :: forall a. Dom Vector a => Vector a -> a
clast = forall a. Vector a -> a
V.last
{-# INLINE [1] chead #-}
chead :: forall a. Dom Vector a => Vector a -> a
chead = forall a. Vector a -> a
V.head
{-# INLINE [1] cfind #-}
cfind :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe a
cfind = forall a. (a -> Bool) -> Vector a -> Maybe a
V.find
{-# INLINE [1] cfindIndex #-}
cfindIndex :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int
cfindIndex = forall a. (a -> Bool) -> Vector a -> Maybe Int
V.findIndex
{-# INLINE [1] cfindIndices #-}
cfindIndices :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> [Int]
cfindIndices = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Vector a -> [a]
V.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices
{-# INLINE [1] celemIndex #-}
celemIndex :: forall a. (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int
celemIndex = forall a. Eq a => a -> Vector a -> Maybe Int
V.elemIndex
{-# INLINE [1] celemIndices #-}
celemIndices :: forall a. (Dom Vector a, Eq a) => a -> Vector a -> [Int]
celemIndices = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Vector a -> [a]
V.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => a -> Vector a -> Vector Int
V.elemIndices
instance CFoldable U.Vector where
{-# INLINE [1] cfoldMap #-}
cfoldMap :: forall a m. (Dom Vector a, Monoid m) => (a -> m) -> Vector a -> m
cfoldMap = forall mono m.
(MonoFoldable mono, Monoid m) =>
(Element mono -> m) -> mono -> m
ofoldMap
{-# INLINE [1] cfoldr #-}
cfoldr :: forall a b. Dom Vector a => (a -> b -> b) -> b -> Vector a -> b
cfoldr = forall a b. Unbox a => (a -> b -> b) -> b -> Vector a -> b
U.foldr
{-# INLINE [1] cfoldr' #-}
cfoldr' :: forall a b. Dom Vector a => (a -> b -> b) -> b -> Vector a -> b
cfoldr' = forall a b. Unbox a => (a -> b -> b) -> b -> Vector a -> b
U.foldr'
{-# INLINE [1] cfoldl #-}
cfoldl :: forall a b. Dom Vector a => (b -> a -> b) -> b -> Vector a -> b
cfoldl = forall b a. Unbox b => (a -> b -> a) -> a -> Vector b -> a
U.foldl
{-# INLINE [1] cfoldl' #-}
cfoldl' :: forall a b. Dom Vector a => (b -> a -> b) -> b -> Vector a -> b
cfoldl' = forall b a. Unbox b => (a -> b -> a) -> a -> Vector b -> a
U.foldl'
{-# INLINE cfoldlM #-}
cfoldlM :: forall (m :: * -> *) b a.
(Monad m, Dom Vector b) =>
(a -> b -> m a) -> a -> Vector b -> m a
cfoldlM = forall (m :: * -> *) b a.
(Monad m, Unbox b) =>
(a -> b -> m a) -> a -> Vector b -> m a
U.foldM
{-# INLINE cfoldlM' #-}
cfoldlM' :: forall (m :: * -> *) b a.
(Monad m, Dom Vector b) =>
(a -> b -> m a) -> a -> Vector b -> m a
cfoldlM' = forall (m :: * -> *) b a.
(Monad m, Unbox b) =>
(a -> b -> m a) -> a -> Vector b -> m a
U.foldM'
{-# INLINE [1] cindex #-}
cindex :: forall a. Dom Vector a => Vector a -> Int -> a
cindex = forall a. Unbox a => Vector a -> Int -> a
(U.!)
{-# INLINE [1] celem #-}
celem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
celem = forall a. (Unbox a, Eq a) => a -> Vector a -> Bool
U.elem
{-# INLINE [1] cnotElem #-}
cnotElem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
cnotElem = forall a. (Unbox a, Eq a) => a -> Vector a -> Bool
U.notElem
{-# INLINE [1] cany #-}
cany :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
cany = forall a. Unbox a => (a -> Bool) -> Vector a -> Bool
U.any
{-# INLINE [1] call #-}
call :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
call = forall a. Unbox a => (a -> Bool) -> Vector a -> Bool
U.all
{-# INLINE [1] cfoldl1 #-}
cfoldl1 :: forall a. Dom Vector a => (a -> a -> a) -> Vector a -> a
cfoldl1 = forall a. Unbox a => (a -> a -> a) -> Vector a -> a
U.foldl1
{-# INLINE [1] cfoldr1 #-}
cfoldr1 :: forall a. Dom Vector a => (a -> a -> a) -> Vector a -> a
cfoldr1 = forall a. Unbox a => (a -> a -> a) -> Vector a -> a
U.foldr1
{-# INLINE [1] csum #-}
csum :: forall a. (Num a, Dom Vector a) => Vector a -> a
csum = forall a. (Unbox a, Num a) => Vector a -> a
U.sum
{-# INLINE [1] cproduct #-}
cproduct :: forall a. (Num a, Dom Vector a) => Vector a -> a
cproduct = forall a. (Unbox a, Num a) => Vector a -> a
U.product
{-# INLINE [1] cmaximum #-}
cmaximum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cmaximum = forall a. (Unbox a, Ord a) => Vector a -> a
U.maximum
{-# INLINE [1] cminimum #-}
cminimum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cminimum = forall a. (Unbox a, Ord a) => Vector a -> a
U.minimum
{-# INLINE cbasicToList #-}
cbasicToList :: forall a. Dom Vector a => Vector a -> [a]
cbasicToList = forall a. Unbox a => Vector a -> [a]
U.toList
{-# INLINE [1] clast #-}
clast :: forall a. Dom Vector a => Vector a -> a
clast = forall a. Unbox a => Vector a -> a
U.last
{-# INLINE [1] chead #-}
chead :: forall a. Dom Vector a => Vector a -> a
chead = forall a. Unbox a => Vector a -> a
U.head
{-# INLINE [1] cfind #-}
cfind :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe a
cfind = forall a. Unbox a => (a -> Bool) -> Vector a -> Maybe a
U.find
{-# INLINE [1] cfindIndex #-}
cfindIndex :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int
cfindIndex = forall a. Unbox a => (a -> Bool) -> Vector a -> Maybe Int
U.findIndex
{-# INLINE [1] cfindIndices #-}
cfindIndices :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> [Int]
cfindIndices = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Unbox a => Vector a -> [a]
U.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Unbox a => (a -> Bool) -> Vector a -> Vector Int
U.findIndices
{-# INLINE [1] celemIndex #-}
celemIndex :: forall a. (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int
celemIndex = forall a. (Unbox a, Eq a) => a -> Vector a -> Maybe Int
U.elemIndex
{-# INLINE [1] celemIndices #-}
celemIndices :: forall a. (Dom Vector a, Eq a) => a -> Vector a -> [Int]
celemIndices = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Unbox a => Vector a -> [a]
U.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Unbox a, Eq a) => a -> Vector a -> Vector Int
U.elemIndices
instance CFoldable S.Vector where
{-# INLINE [1] cfoldr #-}
cfoldr :: forall a b. Dom Vector a => (a -> b -> b) -> b -> Vector a -> b
cfoldr = forall a b. Storable a => (a -> b -> b) -> b -> Vector a -> b
S.foldr
{-# INLINE [1] cfoldr' #-}
cfoldr' :: forall a b. Dom Vector a => (a -> b -> b) -> b -> Vector a -> b
cfoldr' = forall a b. Storable a => (a -> b -> b) -> b -> Vector a -> b
S.foldr'
{-# INLINE [1] cfoldl #-}
cfoldl :: forall a b. Dom Vector a => (b -> a -> b) -> b -> Vector a -> b
cfoldl = forall b a. Storable b => (a -> b -> a) -> a -> Vector b -> a
S.foldl
{-# INLINE [1] cfoldl' #-}
cfoldl' :: forall a b. Dom Vector a => (b -> a -> b) -> b -> Vector a -> b
cfoldl' = forall b a. Storable b => (a -> b -> a) -> a -> Vector b -> a
S.foldl'
{-# INLINE cfoldlM #-}
cfoldlM :: forall (m :: * -> *) b a.
(Monad m, Dom Vector b) =>
(a -> b -> m a) -> a -> Vector b -> m a
cfoldlM = forall (m :: * -> *) b a.
(Monad m, Storable b) =>
(a -> b -> m a) -> a -> Vector b -> m a
S.foldM
{-# INLINE cfoldlM' #-}
cfoldlM' :: forall (m :: * -> *) b a.
(Monad m, Dom Vector b) =>
(a -> b -> m a) -> a -> Vector b -> m a
cfoldlM' = forall (m :: * -> *) b a.
(Monad m, Storable b) =>
(a -> b -> m a) -> a -> Vector b -> m a
S.foldM'
{-# INLINE [1] cindex #-}
cindex :: forall a. Dom Vector a => Vector a -> Int -> a
cindex = forall a. Storable a => Vector a -> Int -> a
(S.!)
{-# INLINE [1] celem #-}
celem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
celem = forall a. (Storable a, Eq a) => a -> Vector a -> Bool
S.elem
{-# INLINE [1] cnotElem #-}
cnotElem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
cnotElem = forall a. (Storable a, Eq a) => a -> Vector a -> Bool
S.notElem
{-# INLINE [1] cany #-}
cany :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
cany = forall a. Storable a => (a -> Bool) -> Vector a -> Bool
S.any
{-# INLINE [1] call #-}
call :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
call = forall a. Storable a => (a -> Bool) -> Vector a -> Bool
S.all
{-# INLINE [1] cfoldl1 #-}
cfoldl1 :: forall a. Dom Vector a => (a -> a -> a) -> Vector a -> a
cfoldl1 = forall a. Storable a => (a -> a -> a) -> Vector a -> a
S.foldl1
{-# INLINE [1] cfoldr1 #-}
cfoldr1 :: forall a. Dom Vector a => (a -> a -> a) -> Vector a -> a
cfoldr1 = forall a. Storable a => (a -> a -> a) -> Vector a -> a
S.foldr1
{-# INLINE [1] csum #-}
csum :: forall a. (Num a, Dom Vector a) => Vector a -> a
csum = forall a. (Storable a, Num a) => Vector a -> a
S.sum
{-# INLINE [1] cproduct #-}
cproduct :: forall a. (Num a, Dom Vector a) => Vector a -> a
cproduct = forall a. (Storable a, Num a) => Vector a -> a
S.product
{-# INLINE [1] cmaximum #-}
cmaximum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cmaximum = forall a. (Storable a, Ord a) => Vector a -> a
S.maximum
{-# INLINE [1] cminimum #-}
cminimum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cminimum = forall a. (Storable a, Ord a) => Vector a -> a
S.minimum
{-# INLINE cbasicToList #-}
cbasicToList :: forall a. Dom Vector a => Vector a -> [a]
cbasicToList = forall a. Storable a => Vector a -> [a]
S.toList
{-# INLINE [1] clast #-}
clast :: forall a. Dom Vector a => Vector a -> a
clast = forall a. Storable a => Vector a -> a
S.last
{-# INLINE [1] chead #-}
chead :: forall a. Dom Vector a => Vector a -> a
chead = forall a. Storable a => Vector a -> a
S.head
{-# INLINE [1] cfind #-}
cfind :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe a
cfind = forall a. Storable a => (a -> Bool) -> Vector a -> Maybe a
S.find
{-# INLINE [1] cfindIndex #-}
cfindIndex :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int
cfindIndex = forall a. Storable a => (a -> Bool) -> Vector a -> Maybe Int
S.findIndex
{-# INLINE [1] cfindIndices #-}
cfindIndices :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> [Int]
cfindIndices = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Storable a => Vector a -> [a]
S.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => (a -> Bool) -> Vector a -> Vector Int
S.findIndices
{-# INLINE [1] celemIndex #-}
celemIndex :: forall a. (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int
celemIndex = forall a. (Storable a, Eq a) => a -> Vector a -> Maybe Int
S.elemIndex
{-# INLINE [1] celemIndices #-}
celemIndices :: forall a. (Dom Vector a, Eq a) => a -> Vector a -> [Int]
celemIndices = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Storable a => Vector a -> [a]
S.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Storable a, Eq a) => a -> Vector a -> Vector Int
S.elemIndices
instance CFoldable P.Vector where
{-# INLINE [1] cfoldr #-}
cfoldr :: forall a b. Dom Vector a => (a -> b -> b) -> b -> Vector a -> b
cfoldr = forall a b. Prim a => (a -> b -> b) -> b -> Vector a -> b
P.foldr
{-# INLINE [1] cfoldr' #-}
cfoldr' :: forall a b. Dom Vector a => (a -> b -> b) -> b -> Vector a -> b
cfoldr' = forall a b. Prim a => (a -> b -> b) -> b -> Vector a -> b
P.foldr'
{-# INLINE [1] cfoldl #-}
cfoldl :: forall a b. Dom Vector a => (b -> a -> b) -> b -> Vector a -> b
cfoldl = forall b a. Prim b => (a -> b -> a) -> a -> Vector b -> a
P.foldl
{-# INLINE [1] cfoldl' #-}
cfoldl' :: forall a b. Dom Vector a => (b -> a -> b) -> b -> Vector a -> b
cfoldl' = forall b a. Prim b => (a -> b -> a) -> a -> Vector b -> a
P.foldl'
{-# INLINE cfoldlM #-}
cfoldlM :: forall (m :: * -> *) b a.
(Monad m, Dom Vector b) =>
(a -> b -> m a) -> a -> Vector b -> m a
cfoldlM = forall (m :: * -> *) b a.
(Monad m, Prim b) =>
(a -> b -> m a) -> a -> Vector b -> m a
P.foldM
{-# INLINE cfoldlM' #-}
cfoldlM' :: forall (m :: * -> *) b a.
(Monad m, Dom Vector b) =>
(a -> b -> m a) -> a -> Vector b -> m a
cfoldlM' = forall (m :: * -> *) b a.
(Monad m, Prim b) =>
(a -> b -> m a) -> a -> Vector b -> m a
P.foldM'
{-# INLINE [1] cindex #-}
cindex :: forall a. Dom Vector a => Vector a -> Int -> a
cindex = forall a. Prim a => Vector a -> Int -> a
(P.!)
{-# INLINE [1] celem #-}
celem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
celem = forall a. (Prim a, Eq a) => a -> Vector a -> Bool
P.elem
{-# INLINE [1] cnotElem #-}
cnotElem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
cnotElem = forall a. (Prim a, Eq a) => a -> Vector a -> Bool
P.notElem
{-# INLINE [1] cany #-}
cany :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
cany = forall a. Prim a => (a -> Bool) -> Vector a -> Bool
P.any
{-# INLINE [1] call #-}
call :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
call = forall a. Prim a => (a -> Bool) -> Vector a -> Bool
P.all
{-# INLINE [1] cfoldl1 #-}
cfoldl1 :: forall a. Dom Vector a => (a -> a -> a) -> Vector a -> a
cfoldl1 = forall a. Prim a => (a -> a -> a) -> Vector a -> a
P.foldl1
{-# INLINE [1] cfoldr1 #-}
cfoldr1 :: forall a. Dom Vector a => (a -> a -> a) -> Vector a -> a
cfoldr1 = forall a. Prim a => (a -> a -> a) -> Vector a -> a
P.foldr1
{-# INLINE [1] csum #-}
csum :: forall a. (Num a, Dom Vector a) => Vector a -> a
csum = forall a. (Prim a, Num a) => Vector a -> a
P.sum
{-# INLINE [1] cproduct #-}
cproduct :: forall a. (Num a, Dom Vector a) => Vector a -> a
cproduct = forall a. (Prim a, Num a) => Vector a -> a
P.product
{-# INLINE [1] cmaximum #-}
cmaximum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cmaximum = forall a. (Prim a, Ord a) => Vector a -> a
P.maximum
{-# INLINE [1] cminimum #-}
cminimum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cminimum = forall a. (Prim a, Ord a) => Vector a -> a
P.minimum
{-# INLINE cbasicToList #-}
cbasicToList :: forall a. Dom Vector a => Vector a -> [a]
cbasicToList = forall a. Prim a => Vector a -> [a]
P.toList
{-# INLINE [1] clast #-}
clast :: forall a. Dom Vector a => Vector a -> a
clast = forall a. Prim a => Vector a -> a
P.last
{-# INLINE [1] chead #-}
chead :: forall a. Dom Vector a => Vector a -> a
chead = forall a. Prim a => Vector a -> a
P.head
{-# INLINE [1] cfind #-}
cfind :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe a
cfind = forall a. Prim a => (a -> Bool) -> Vector a -> Maybe a
P.find
{-# INLINE [1] cfindIndex #-}
cfindIndex :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe Int
cfindIndex = forall a. Prim a => (a -> Bool) -> Vector a -> Maybe Int
P.findIndex
{-# INLINE [1] cfindIndices #-}
cfindIndices :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> [Int]
cfindIndices = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Prim a => Vector a -> [a]
P.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Prim a => (a -> Bool) -> Vector a -> Vector Int
P.findIndices
{-# INLINE [1] celemIndex #-}
celemIndex :: forall a. (Dom Vector a, Eq a) => a -> Vector a -> Maybe Int
celemIndex = forall a. (Prim a, Eq a) => a -> Vector a -> Maybe Int
P.elemIndex
{-# INLINE [1] celemIndices #-}
celemIndices :: forall a. (Dom Vector a, Eq a) => a -> Vector a -> [Int]
celemIndices = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Prim a => Vector a -> [a]
P.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Prim a, Eq a) => a -> Vector a -> Vector Int
P.elemIndices
instance CTraversable V.Vector where
ctraverse :: forall a b (g :: * -> *).
(Dom Vector a, Dom Vector b, Applicative g) =>
(a -> g b) -> Vector a -> g (Vector b)
ctraverse = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
{-# INLINE [1] ctraverse #-}
instance CTraversable U.Vector where
ctraverse :: forall a b (g :: * -> *).
(Dom Vector a, Dom Vector b, Applicative g) =>
(a -> g b) -> Vector a -> g (Vector b)
ctraverse = \a -> g b
f -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
S.convert forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> g b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
U.convert @_ @_ @V.Vector
{-# INLINE [1] ctraverse #-}
instance CTraversable S.Vector where
ctraverse :: forall a b (g :: * -> *).
(Dom Vector a, Dom Vector b, Applicative g) =>
(a -> g b) -> Vector a -> g (Vector b)
ctraverse = \a -> g b
f -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
S.convert forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> g b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
U.convert @_ @_ @V.Vector
{-# INLINE [1] ctraverse #-}
instance CTraversable P.Vector where
ctraverse :: forall a b (g :: * -> *).
(Dom Vector a, Dom Vector b, Applicative g) =>
(a -> g b) -> Vector a -> g (Vector b)
ctraverse = \a -> g b
f -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
P.convert forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> g b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
U.convert @_ @_ @V.Vector
{-# INLINE [1] ctraverse #-}
{-# RULES
"cindex/IsSequence" forall (xs :: (MT.Index mono ~ Int, IsSequence mono) => WrapMono mono b).
cindex xs = withMonoCoercible (coerce @(mono -> Int -> Element mono) indexEx xs)
#-}
{-# RULES
"cfromList/ctoList" [~1]
cfromList . ctoList = id
"cfromList/ctoList" [~1] forall xs.
cfromList (ctoList xs) = xs
#-}
{-# RULES
"ctoList/cfromList" [~1]
ctoList . cfromList = id
"ctoList/cfromList" forall xs.
ctoList (cfromList xs) = xs
#-}
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
cbasicFromList = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (forall a. Semigroup a => a -> a -> a
(<>) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure) forall a. Monoid a => a
mempty
{-# INLINE cbasicFromList #-}
ccons :: Dom f a => a -> f a -> f a
{-# INLINE [1] ccons #-}
ccons = forall a. Semigroup a => a -> a -> a
(<>) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure
csnoc :: Dom f a => f a -> a -> f a
{-# INLINE [1] csnoc #-}
csnoc = (forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Semigroup a => a -> a -> a
(<>)
cfromListN :: Dom f a => Int -> [a] -> f a
cfromListN = forall a b. a -> b -> a
const forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList
{-# INLINE [1] cfromListN #-}
ctake :: Dom f a => Int -> f a -> f a
{-# INLINE [1] ctake #-}
ctake Int
n = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
take Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cdrop :: Dom f a => Int -> f a -> f a
{-# INLINE [1] cdrop #-}
cdrop Int
n = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cinit :: Dom f a => f a -> f a
{-# INLINE [1] cinit #-}
cinit = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
init forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
ctail :: Dom f a => f a -> f a
ctail = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
tail forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
csplitAt :: Dom f a => Int -> f a -> (f a, f a)
{-# INLINE [1] csplitAt #-}
csplitAt Int
n = (\([a]
a, [a]
b) -> (forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList [a]
a, forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList [a]
b)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> ([a], [a])
splitAt Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
creplicate :: Dom f a => Int -> a -> f a
{-# INLINE [1] creplicate #-}
creplicate Int
n = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> a -> [a]
replicate Int
n
cgenerate :: Dom f a => Int -> (Int -> a) -> f a
{-# INLINE [1] cgenerate #-}
cgenerate = \Int
n Int -> a
f ->
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList [Int -> a
f Int
i | Int
i <- [Int
0.. Int
n forall a. Num a => a -> a -> a
- Int
1]]
cgenerateM :: (Dom f a, Monad m) => Int -> (Int -> m a) -> m (f a)
{-# INLINE [1] cgenerateM #-}
cgenerateM = \Int
n Int -> m a
f ->
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Int -> m a
f [Int
0..Int
nforall a. Num a => a -> a -> a
-Int
1]
cgenerateA :: (Dom f a, Applicative g) => Int -> (Int -> g a) -> g (f a)
{-# INLINE [1] cgenerateA #-}
cgenerateA = \Int
n Int -> g a
f ->
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Int -> g a
f [Int
0..Int
nforall a. Num a => a -> a -> a
-Int
1]
cuncons :: Dom f a => f a -> Maybe (a, f a)
{-# INLINE [1] cuncons #-}
cuncons = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe (a, [a])
uncons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cunsnoc :: Dom f a => f a -> Maybe (f a, a)
{-# INLINE [1] cunsnoc #-}
cunsnoc = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall seq. IsSequence seq => seq -> Maybe (seq, Element seq)
MT.unsnoc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
creverse :: Dom f a => f a -> f a
{-# INLINE [1] creverse #-}
creverse = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cintersperse :: Dom f a => a -> f a -> f a
cintersperse = \a
a -> forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [a] -> [a]
intersperse a
a forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cnub :: (Dom f a, Eq a) => f a -> f a
{-# INLINE [1] cnub #-}
cnub = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => [a] -> [a]
nub forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cnubOrd :: (Dom f a, Ord a) => f a -> f a
{-# INLINE [1] cnubOrd #-}
cnubOrd = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a b. Handler s a -> Fold a b -> s -> b
L.foldOver forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded forall a. Ord a => Fold a [a]
L.nub
csort :: (Dom f a, Ord a) => f a -> f a
{-# INLINE [1] csort #-}
csort = forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> [a]
List.sort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
csortBy :: (Dom f a) => (a -> a -> Ordering) -> f a -> f a
{-# INLINE [1] csortBy #-}
csortBy = \a -> a -> Ordering
f -> forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy a -> a -> Ordering
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cinsert :: (Dom f a, Ord a) => a -> f a -> f a
{-# INLINE [1] cinsert #-}
cinsert = \a
a -> forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => a -> [a] -> [a]
List.insert a
a forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cinsertBy :: (Dom f a) => (a -> a -> Ordering) -> a -> f a -> f a
{-# INLINE [1] cinsertBy #-}
cinsertBy = \a -> a -> Ordering
f a
a -> forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a -> Ordering) -> a -> [a] -> [a]
List.insertBy a -> a -> Ordering
f a
a forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
ctakeWhile :: Dom f a => (a -> Bool) -> f a -> f a
{-# INLINE [1] ctakeWhile #-}
ctakeWhile = \a -> Bool
f -> forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
takeWhile a -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cdropWhile :: Dom f a => (a -> Bool) -> f a -> f a
{-# INLINE [1] cdropWhile #-}
cdropWhile = \a -> Bool
f -> forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile a -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cspan :: Dom f a => (a -> Bool) -> f a -> (f a, f a)
{-# INLINE [1] cspan #-}
cspan = \a -> Bool
f -> (forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> ([a], [a])
span a -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cbreak :: Dom f a => (a -> Bool) -> f a -> (f a, f a)
{-# INLINE [1] cbreak #-}
cbreak = \a -> Bool
f -> (forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> ([a], [a])
break a -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cfilter :: Dom f a => (a -> Bool) -> f a -> f a
{-# INLINE [1] cfilter #-}
cfilter = \a -> Bool
f -> forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter a -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
cpartition :: Dom f a => (a -> Bool) -> f a -> (f a, f a)
{-# INLINE [1] cpartition #-}
cpartition = \a -> Bool
f -> (forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> ([a], [a])
List.partition a -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList
instance CFreeMonoid [] where
cbasicFromList :: forall a. Dom [] a => [a] -> [a]
cbasicFromList = forall a. a -> a
id
{-# INLINE cbasicFromList #-}
cfromListN :: forall a. Dom [] a => Int -> [a] -> [a]
cfromListN = forall a. Int -> [a] -> [a]
take
{-# INLINE [1] cfromListN #-}
ccons :: forall a. Dom [] a => a -> [a] -> [a]
ccons = (:)
{-# INLINE [1] ccons #-}
csnoc :: forall a. Dom [] a => [a] -> a -> [a]
csnoc = \[a]
xs a
x -> [a]
xs forall a. [a] -> [a] -> [a]
++ [a
x]
{-# INLINE [1] csnoc #-}
ctake :: forall a. Dom [] a => Int -> [a] -> [a]
ctake = forall a. Int -> [a] -> [a]
take
{-# INLINE [1] ctake #-}
cdrop :: forall a. Dom [] a => Int -> [a] -> [a]
cdrop = forall a. Int -> [a] -> [a]
drop
{-# INLINE [1] cdrop #-}
cinit :: forall a. Dom [] a => [a] -> [a]
cinit = forall a. [a] -> [a]
init
{-# INLINE [1] cinit #-}
ctail :: forall a. Dom [] a => [a] -> [a]
ctail = forall a. [a] -> [a]
tail
{-# INLINE [1] ctail #-}
csplitAt :: forall a. Dom [] a => Int -> [a] -> ([a], [a])
csplitAt = forall a. Int -> [a] -> ([a], [a])
splitAt
{-# INLINE [1] csplitAt #-}
creplicate :: forall a. Dom [] a => Int -> a -> [a]
creplicate = forall a. Int -> a -> [a]
replicate
{-# INLINE [1] creplicate #-}
cgenerateM :: forall a (m :: * -> *).
(Dom [] a, Monad m) =>
Int -> (Int -> m a) -> m [a]
cgenerateM = \Int
n Int -> m a
f -> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Int -> m a
f [Int
0..Int
nforall a. Num a => a -> a -> a
-Int
1]
{-# INLINE [1] cgenerateM #-}
cgenerateA :: forall a (g :: * -> *).
(Dom [] a, Applicative g) =>
Int -> (Int -> g a) -> g [a]
cgenerateA = \Int
n Int -> g a
f -> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Int -> g a
f [Int
0..Int
nforall a. Num a => a -> a -> a
-Int
1]
{-# INLINE [1] cgenerateA #-}
cuncons :: forall a. Dom [] a => [a] -> Maybe (a, [a])
cuncons = forall a. [a] -> Maybe (a, [a])
uncons
{-# INLINE [1] cuncons #-}
cunsnoc :: forall a. Dom [] a => [a] -> Maybe ([a], a)
cunsnoc = forall seq. IsSequence seq => seq -> Maybe (seq, Element seq)
MT.unsnoc
{-# INLINE [1] cunsnoc #-}
creverse :: forall a. Dom [] a => [a] -> [a]
creverse = forall a. [a] -> [a]
reverse
{-# INLINE [1] creverse #-}
cintersperse :: forall a. Dom [] a => a -> [a] -> [a]
cintersperse = forall a. a -> [a] -> [a]
intersperse
{-# INLINE [1] cintersperse #-}
cnub :: forall a. (Dom [] a, Eq a) => [a] -> [a]
cnub = forall (f :: * -> *) a.
(CFreeMonoid f, Dom f a, Eq a) =>
f a -> f a
cnub
{-# INLINE [1] cnub #-}
csort :: forall a. (Dom [] a, Ord a) => [a] -> [a]
csort = forall a. Ord a => [a] -> [a]
List.sort
{-# INLINE [1] csort #-}
csortBy :: forall a. Dom [] a => (a -> a -> Ordering) -> [a] -> [a]
csortBy = forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy
{-# INLINE [1] csortBy #-}
ctakeWhile :: forall a. Dom [] a => (a -> Bool) -> [a] -> [a]
ctakeWhile = forall a. (a -> Bool) -> [a] -> [a]
takeWhile
{-# INLINE [1] ctakeWhile #-}
cdropWhile :: forall a. Dom [] a => (a -> Bool) -> [a] -> [a]
cdropWhile = forall a. (a -> Bool) -> [a] -> [a]
dropWhile
{-# INLINE [1] cdropWhile #-}
cspan :: forall a. Dom [] a => (a -> Bool) -> [a] -> ([a], [a])
cspan = forall a. (a -> Bool) -> [a] -> ([a], [a])
span
{-# INLINE [1] cspan #-}
cbreak :: forall a. Dom [] a => (a -> Bool) -> [a] -> ([a], [a])
cbreak = forall a. (a -> Bool) -> [a] -> ([a], [a])
break
{-# INLINE [1] cbreak #-}
cfilter :: forall a. Dom [] a => (a -> Bool) -> [a] -> [a]
cfilter = forall a. (a -> Bool) -> [a] -> [a]
filter
{-# INLINE [1] cfilter #-}
cpartition :: forall a. Dom [] a => (a -> Bool) -> [a] -> ([a], [a])
cpartition = forall a. (a -> Bool) -> [a] -> ([a], [a])
List.partition
{-# INLINE [1] cpartition #-}
fmap concat $ forM
[''V.Vector, ''U.Vector, ''S.Vector, ''P.Vector]
$ \vecTy@(Name _ (NameG _ pkg modl0@(ModName mn))) ->
let modl = maybe modl0 (ModName . T.unpack)
$ T.stripSuffix ".Base" $ T.pack mn
modFun fun = varE $
Name (OccName fun) (NameG VarName pkg modl)
in [d|
instance CFreeMonoid $(conT vecTy) where
cbasicFromList = $(modFun "fromList")
{-# INLINE cbasicFromList #-}
cfromListN = $(modFun "fromListN")
{-# INLINE [1] cfromListN #-}
ccons = $(modFun "cons")
{-# INLINE [1] ccons #-}
csnoc = $(modFun "snoc")
{-# INLINE [1] csnoc #-}
ctake = $(modFun "take")
{-# INLINE [1] ctake #-}
cdrop = $(modFun "drop")
{-# INLINE [1] cdrop #-}
cinit = $(modFun "init")
{-# INLINE [1] cinit #-}
ctail = $(modFun "tail")
{-# INLINE [1] ctail #-}
csplitAt = $(modFun "splitAt")
{-# INLINE [1] csplitAt #-}
creplicate = $(modFun "replicate")
{-# INLINE [1] creplicate #-}
cgenerate = $(modFun "generate")
{-# INLINE [1] cgenerate #-}
cgenerateM = $(modFun "generateM")
{-# INLINE [1] cgenerateM #-}
cgenerateA = \n f ->
fmap VB.build
$ getAp $ foldMap (Ap . fmap VB.singleton . f) [0..n-1]
{-# INLINE [1] cgenerateA #-}
cuncons = \xs ->
if $(modFun "null") xs
then Nothing
else Just ($(modFun "head") xs, $(modFun "tail") xs)
{-# INLINE [1] cuncons #-}
cunsnoc = \xs ->
if $(modFun "null") xs
then Nothing
else Just ($(modFun "init") xs, $(modFun "last") xs)
{-# INLINE [1] cunsnoc #-}
creverse = $(modFun "reverse")
{-# INLINE [1] creverse #-}
cnubOrd = $(modFun "uniq") . $(modFun "modify") AI.sort
{-# INLINE cnubOrd #-}
csort = $(modFun "modify") AI.sort
{-# INLINE [1] csort #-}
csortBy = \f -> $(modFun "modify") $ AI.sortBy f
{-# INLINE [1] csortBy #-}
ctakeWhile = $(modFun "takeWhile")
{-# INLINE [1] ctakeWhile #-}
cdropWhile = $(modFun "dropWhile")
{-# INLINE [1] cdropWhile #-}
cspan = $(modFun "span")
{-# INLINE [1] cspan #-}
cbreak = $(modFun "break")
{-# INLINE [1] cbreak #-}
cfilter = $(modFun "filter")
{-# INLINE [1] cfilter #-}
cpartition = $(modFun "partition")
{-# INLINE [1] cpartition #-}
|]
instance CFreeMonoid PA.PrimArray where
cbasicFromList :: forall a. Dom PrimArray a => [a] -> PrimArray a
cbasicFromList = forall a. Prim a => [a] -> PrimArray a
PA.primArrayFromList
{-# INLINE cbasicFromList #-}
cfromListN :: forall a. Dom PrimArray a => Int -> [a] -> PrimArray a
cfromListN = forall a. Prim a => Int -> [a] -> PrimArray a
PA.primArrayFromListN
{-# INLINE [1] cfromListN #-}
cgenerate :: forall a. Dom PrimArray a => Int -> (Int -> a) -> PrimArray a
cgenerate = forall a. Prim a => Int -> (Int -> a) -> PrimArray a
PA.generatePrimArray
{-# INLINE [1] cgenerate #-}
cgenerateM :: forall a (m :: * -> *).
(Dom PrimArray a, Monad m) =>
Int -> (Int -> m a) -> m (PrimArray a)
cgenerateM = forall (f :: * -> *) a.
(Applicative f, Prim a) =>
Int -> (Int -> f a) -> f (PrimArray a)
PA.generatePrimArrayA
{-# INLINE [1] cgenerateM #-}
cgenerateA :: forall a (g :: * -> *).
(Dom PrimArray a, Applicative g) =>
Int -> (Int -> g a) -> g (PrimArray a)
cgenerateA = forall (f :: * -> *) a.
(Applicative f, Prim a) =>
Int -> (Int -> f a) -> f (PrimArray a)
PA.generatePrimArrayA
{-# INLINE [1] cgenerateA #-}
cfilter :: forall a.
Dom PrimArray a =>
(a -> Bool) -> PrimArray a -> PrimArray a
cfilter = forall a. Prim a => (a -> Bool) -> PrimArray a -> PrimArray a
PA.filterPrimArray
{-# INLINE [1] cfilter #-}
creplicate :: forall a. Dom PrimArray a => Int -> a -> PrimArray a
creplicate = forall a. Prim a => Int -> a -> PrimArray a
PA.replicatePrimArray
{-# INLINE [1] creplicate #-}
instance CFreeMonoid SA.SmallArray where
cbasicFromList :: forall a. Dom SmallArray a => [a] -> SmallArray a
cbasicFromList = forall a. [a] -> SmallArray a
SA.smallArrayFromList
{-# INLINE cbasicFromList #-}
cfromListN :: forall a. Dom SmallArray a => Int -> [a] -> SmallArray a
cfromListN = forall a. Int -> [a] -> SmallArray a
SA.smallArrayFromListN
{-# INLINE [1] cfromListN #-}
instance CFreeMonoid A.Array where
#if MIN_VERSION_primitive(0,9,0)
cbasicFromList :: forall a. Dom Array a => [a] -> Array a
cbasicFromList = forall a. [a] -> Array a
A.arrayFromList
{-# INLINE cbasicFromList #-}
cfromListN :: forall a. Dom Array a => Int -> [a] -> Array a
cfromListN = forall a. Int -> [a] -> Array a
A.arrayFromListN
{-# INLINE [1] cfromListN #-}
#else
cbasicFromList = A.fromList
{-# INLINE cbasicFromList #-}
cfromListN = A.fromListN
{-# INLINE [1] cfromListN #-}
#endif
instance CFreeMonoid Seq.Seq where
cbasicFromList :: forall a. Dom Seq a => [a] -> Seq a
cbasicFromList = forall a. [a] -> Seq a
Seq.fromList
{-# INLINE cbasicFromList #-}
cfromListN :: forall a. Dom Seq a => Int -> [a] -> Seq a
cfromListN = forall l. IsList l => Int -> [Item l] -> l
GHC.fromListN
{-# INLINE [1] cfromListN #-}
instance MT.IsSequence mono
=> CFreeMonoid (WrapMono mono) where
cbasicFromList :: forall a. Dom (WrapMono mono) a => [a] -> WrapMono mono a
cbasicFromList = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => [Element seq] -> seq
MT.fromList @mono
{-# INLINE cbasicFromList #-}
cfromListN :: forall a. Dom (WrapMono mono) a => Int -> [a] -> WrapMono mono a
cfromListN = \Int
n -> coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => Index seq -> seq -> seq
MT.take (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall seq. IsSequence seq => [Element seq] -> seq
MT.fromList @mono
{-# INLINE [1] cfromListN #-}
ctake :: forall a.
Dom (WrapMono mono) a =>
Int -> WrapMono mono a -> WrapMono mono a
ctake = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall seq. IsSequence seq => Index seq -> seq -> seq
MT.take @mono forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
{-# INLINE [1] ctake #-}
cdrop :: forall a.
Dom (WrapMono mono) a =>
Int -> WrapMono mono a -> WrapMono mono a
cdrop = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall seq. IsSequence seq => Index seq -> seq -> seq
MT.drop @mono forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
{-# INLINE [1] cdrop #-}
ccons :: forall a.
Dom (WrapMono mono) a =>
a -> WrapMono mono a -> WrapMono mono a
ccons = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. SemiSequence seq => Element seq -> seq -> seq
MT.cons @mono
{-# INLINE ccons #-}
csnoc :: forall a.
Dom (WrapMono mono) a =>
WrapMono mono a -> a -> WrapMono mono a
csnoc = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. SemiSequence seq => seq -> Element seq -> seq
MT.snoc @mono
{-# INLINE [1] csnoc #-}
cuncons :: forall a.
Dom (WrapMono mono) a =>
WrapMono mono a -> Maybe (a, WrapMono mono a)
cuncons = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => seq -> Maybe (Element seq, seq)
MT.uncons @mono
{-# INLINE [1] cuncons #-}
cunsnoc :: forall a.
Dom (WrapMono mono) a =>
WrapMono mono a -> Maybe (WrapMono mono a, a)
cunsnoc = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => seq -> Maybe (seq, Element seq)
MT.unsnoc @mono
{-# INLINE [1] cunsnoc #-}
ctail :: forall a.
Dom (WrapMono mono) a =>
WrapMono mono a -> WrapMono mono a
ctail = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => seq -> seq
MT.tailEx @mono
{-# INLINE [1] ctail #-}
cinit :: forall a.
Dom (WrapMono mono) a =>
WrapMono mono a -> WrapMono mono a
cinit = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => seq -> seq
MT.initEx @mono
{-# INLINE [1] cinit #-}
csplitAt :: forall a.
Dom (WrapMono mono) a =>
Int -> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)
csplitAt = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ \(Int
n :: Int) ->
forall seq. IsSequence seq => Index seq -> seq -> (seq, seq)
MT.splitAt @mono (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n :: MT.Index mono)
{-# INLINE [1] csplitAt #-}
creplicate :: forall a. Dom (WrapMono mono) a => Int -> a -> WrapMono mono a
creplicate = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ \(Int
n :: Int) ->
forall seq. IsSequence seq => Index seq -> Element seq -> seq
MT.replicate @mono (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n :: MT.Index mono)
{-# INLINE [1] creplicate #-}
creverse :: forall a.
Dom (WrapMono mono) a =>
WrapMono mono a -> WrapMono mono a
creverse = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. SemiSequence seq => seq -> seq
MT.reverse @mono
{-# INLINE [1] creverse #-}
cintersperse :: forall a.
Dom (WrapMono mono) a =>
a -> WrapMono mono a -> WrapMono mono a
cintersperse = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. SemiSequence seq => Element seq -> seq -> seq
MT.intersperse @mono
{-# INLINE [1] cintersperse #-}
csort :: forall a.
(Dom (WrapMono mono) a, Ord a) =>
WrapMono mono a -> WrapMono mono a
csort = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. (SemiSequence seq, Ord (Element seq)) => seq -> seq
MT.sort @mono
{-# INLINE [1] csort #-}
csortBy :: forall a.
Dom (WrapMono mono) a =>
(a -> a -> Ordering) -> WrapMono mono a -> WrapMono mono a
csortBy = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq.
SemiSequence seq =>
(Element seq -> Element seq -> Ordering) -> seq -> seq
MT.sortBy @mono
{-# INLINE [1] csortBy #-}
ctakeWhile :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool) -> WrapMono mono a -> WrapMono mono a
ctakeWhile = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => (Element seq -> Bool) -> seq -> seq
MT.takeWhile @mono
{-# INLINE [1] ctakeWhile #-}
cdropWhile :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool) -> WrapMono mono a -> WrapMono mono a
cdropWhile = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => (Element seq -> Bool) -> seq -> seq
MT.dropWhile @mono
{-# INLINE [1] cdropWhile #-}
cbreak :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool)
-> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)
cbreak = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq.
IsSequence seq =>
(Element seq -> Bool) -> seq -> (seq, seq)
MT.break @mono
{-# INLINE [1] cbreak #-}
cspan :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool)
-> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)
cspan = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq.
IsSequence seq =>
(Element seq -> Bool) -> seq -> (seq, seq)
MT.span @mono
{-# INLINE [1] cspan #-}
cfilter :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool) -> WrapMono mono a -> WrapMono mono a
cfilter = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq. IsSequence seq => (Element seq -> Bool) -> seq -> seq
MT.filter @mono
{-# INLINE [1] cfilter #-}
cpartition :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool)
-> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)
cpartition = coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall seq.
IsSequence seq =>
(Element seq -> Bool) -> seq -> (seq, seq)
MT.partition @mono
{-# INLINE [1] cpartition #-}
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)
cctraverseFreeMonoid :: forall (t :: * -> *) (f :: * -> *) a b.
(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)
cctraverseFreeMonoid a -> f b
f =
forall {k} (f :: k -> *) (a :: k). CApp f a -> f a
runCApp forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (forall {k} (f :: k -> *) (a :: k). f a -> CApp f a
CApp forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b.
(CFunctor f, Dom f a, Dom f b) =>
(a -> b) -> f a -> f b
cmap forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f b
f)
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)
cctraverseZipFreeMonoid :: forall (t :: * -> *) (f :: * -> *) a b.
(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)
cctraverseZipFreeMonoid a -> f b
f =
forall {k} (f :: k -> *) (a :: k). CZippy f a -> f a
runCZippy forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (forall {k} (f :: k -> *) (a :: k). f a -> CZippy f a
CZippy forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b.
(CFunctor f, Dom f a, Dom f b) =>
(a -> b) -> f a -> f b
cmap forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f b
f)
cfolding
:: (CFoldable t, Dom t a, Contravariant f, Applicative f)
=> (s -> t a)
-> (a -> f a) -> s -> f s
{-# INLINE cfolding #-}
cfolding :: forall (t :: * -> *) a (f :: * -> *) s.
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(s -> t a) -> (a -> f a) -> s -> f s
cfolding = \s -> t a
sfa a -> f a
agb -> forall (f :: * -> *) a b.
(Functor f, Contravariant f) =>
f a -> f b
phantom forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> f a
agb forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> t a
sfa