{-# 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

-- See Note [Function coercion]
(#.) :: 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 = (a -> b) -> a -> c
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 = f a -> [a]
forall a. Dom f a => f a -> [a]
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 = [a] -> f a
forall a. Dom f a => [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cbasicFromList


-- | Fold-optic for 'CFoldable' instances.
--   In the terminology of lens, cfolded is a constrained
--   variant of @folded@ optic.
--
--  @
--    cfolded :: (CFoldable t, Dom t a) => Fold (t a) a
--  @
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 = ((t a -> ()) -> f () -> f (t a)
forall a' a. (a' -> a) -> f a -> f a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap (() -> t a -> ()
forall a b. a -> b -> a
const ()) (f () -> f (t a)) -> (t a -> f ()) -> t a -> f (t a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((t a -> f ()) -> t a -> f (t a))
-> ((a -> f a) -> t a -> f ()) -> (a -> f a) -> t a -> f (t a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> t a -> f ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom t a) =>
(a -> g b) -> t 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 = (a -> w -> w) -> w -> f a -> w
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr (w -> w -> w
forall a. Monoid a => a -> a -> a
mappend (w -> w -> w) -> (a -> w) -> a -> w -> w
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> w
f) w
forall a. Monoid a => a
mempty

  cfoldMap' :: (Dom f a, Monoid m) => (a -> m) -> f a -> m
  {-# INLINE [1] cfoldMap' #-}
  cfoldMap' a -> m
f = (m -> a -> m) -> m -> f a -> m
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (\ m
acc a
a -> m
acc m -> m -> m
forall a. Semigroup a => a -> a -> a
<> a -> m
f a
a) m
forall a. Monoid a => a
mempty

  cfold :: (Dom f w, Monoid w) => f w -> w
  cfold = (w -> w) -> f w -> w
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap w -> w
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 = Endo b -> b -> b
forall a. Endo a -> a -> a
appEndo ((a -> Endo b) -> f a -> Endo b
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap ((b -> b) -> Endo b
forall a. (a -> a) -> Endo a
Endo ((b -> b) -> Endo b) -> (a -> b -> b) -> a -> Endo b
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 = (b -> (a -> m a) -> a -> m a) -> (a -> m a) -> f b -> a -> m a
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
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' a -> m a
forall a. a -> m a
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 m a -> (a -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
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 = (b -> (a -> m a) -> a -> m a) -> (a -> m a) -> f b -> a -> m a
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
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' a -> m a
forall a. a -> m a
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 = ((b -> m b) -> a -> b -> m b) -> (b -> m b) -> f a -> b -> m b
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
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 b -> m b
forall a. a -> m a
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 m b -> (b -> m b) -> m b
forall a b. m a -> (a -> m b) -> m b
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 = ((b -> m b) -> a -> b -> m b) -> (b -> m b) -> f a -> b -> m b
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
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 b -> m b
forall a. a -> m a
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 = Endo b -> b -> b
forall a. Endo a -> a -> a
appEndo (Dual (Endo b) -> Endo b
forall a. Dual a -> a
getDual ((a -> Dual (Endo b)) -> f a -> Dual (Endo b)
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (Endo b -> Dual (Endo b)
forall a. a -> Dual a
Dual (Endo b -> Dual (Endo b)) -> (a -> Endo b) -> a -> Dual (Endo b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> b) -> Endo b
forall a. (a -> a) -> Endo a
Endo ((b -> b) -> Endo b) -> (a -> b -> b) -> a -> Endo b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> a -> b) -> a -> b -> b
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 = ((b -> b) -> a -> b -> b) -> (b -> b) -> f a -> b -> b
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl (b -> b) -> a -> b -> b
f' b -> b
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 (b -> b) -> b -> b
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 = (a -> (b -> b) -> b -> b) -> (b -> b) -> f a -> b -> b
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> (b -> b) -> b -> b
f' b -> b
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 (b -> b) -> b -> b
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 = (a -> [a] -> [a]) -> [a] -> f a -> [a]
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
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 = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"cfoldr1: empty structure")
                    ((a -> Maybe a -> Maybe a) -> Maybe a -> f a -> Maybe a
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> Maybe a -> Maybe a
mf Maybe a
forall a. Maybe a
Nothing f a
xs)
      where
        mf :: a -> Maybe a -> Maybe a
mf a
x Maybe a
m = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
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 = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"cfoldl1: empty structure")
                  ((Maybe a -> a -> Maybe a) -> Maybe a -> f a -> Maybe a
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl Maybe a -> a -> Maybe a
mf Maybe a
forall a. Maybe a
Nothing f a
xs)
    where
      mf :: Maybe a -> a -> Maybe a
mf Maybe a
m a
y = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
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 (Eith' Int a -> a -> Eith' Int a)
-> Eith' Int a -> f a -> Eith' Int a
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
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 (Int -> Eith' Int a
forall a b. a -> Eith' a b
Left' Int
0) f a
xs of
    Right' a
x -> a
x
    Left'{} -> [Char] -> a
forall a. [Char] -> a
errorWithoutStackTrace ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ [Char]
"cindex: index out of bound " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
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 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
n = a -> Eith' Int a
forall a b. b -> Eith' a b
Right' a
x
        | Bool
otherwise = Int -> Eith' Int a
forall a b. a -> Eith' a b
Left' (Int
i Int -> Int -> Int
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 = (a -> Bool -> Bool) -> Bool -> f a -> Bool
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr ((Bool -> Bool) -> a -> Bool -> Bool
forall a b. a -> b -> a
const ((Bool -> Bool) -> a -> Bool -> Bool)
-> (Bool -> Bool) -> a -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Bool -> Bool -> Bool
forall a b. a -> b -> a
const Bool
False) Bool
True

  clength :: Dom f a => f a -> Int
  {-# INLINE [1] clength #-}
  clength = (Int -> a -> Int) -> Int -> f a -> Int
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (\Int
c a
_ -> Int
c Int -> Int -> Int
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 = (Bool -> a -> Bool) -> Bool -> f a -> Bool
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (\Bool
b -> Bool -> Bool -> Bool
(||) Bool
b (Bool -> Bool) -> (a -> Bool) -> a -> Bool
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 = (Bool -> a -> Bool) -> Bool -> f a -> Bool
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(b -> a -> b) -> b -> f a -> b
cfoldl' (\Bool
b -> Bool -> Bool -> Bool
(&&) Bool
b (Bool -> Bool) -> (a -> Bool) -> a -> Bool
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 = (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany ((a -> Bool) -> f a -> Bool)
-> (a -> a -> Bool) -> a -> f a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)

  cnotElem :: (Eq a, Dom f a) => a -> f a -> Bool
  {-# INLINE [1] cnotElem #-}
  cnotElem = (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call ((a -> Bool) -> f a -> Bool)
-> (a -> a -> Bool) -> a -> f a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(/=)

  cminimum :: (Ord a, Dom f a) => f a -> a
  {-# INLINE [1] cminimum #-}
  cminimum =
    Min a -> a
forall a. Min a -> a
getMin
    (Min a -> a) -> (f a -> Min a) -> f a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Min a -> Maybe (Min a) -> Min a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> Min a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"minimum: empty structure")
    (Maybe (Min a) -> Min a) -> (f a -> Maybe (Min a)) -> f a -> Min a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Maybe (Min a)) -> f a -> Maybe (Min a)
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (Min a -> Maybe (Min a)
forall a. a -> Maybe a
Just (Min a -> Maybe (Min a)) -> (a -> Min a) -> a -> Maybe (Min a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Min a
forall a. a -> Min a
Min)

  cmaximum :: (Ord a, Dom f a) => f a -> a
  {-# INLINE [1] cmaximum #-}
  cmaximum =
    Max a -> a
forall a. Max a -> a
getMax
    (Max a -> a) -> (f a -> Max a) -> f a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Max a -> Maybe (Max a) -> Max a
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> Max a
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"cmaximum: empty structure")
    (Maybe (Max a) -> Max a) -> (f a -> Maybe (Max a)) -> f a -> Max a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Maybe (Max a)) -> f a -> Maybe (Max a)
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (Max a -> Maybe (Max a)
forall a. a -> Maybe a
Just (Max a -> Maybe (Max a)) -> (a -> Max a) -> a -> Maybe (Max a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Max a
forall a. a -> Max a
Max)

  csum :: (Num a, Dom f a) => f a -> a
  {-# INLINE [1] csum #-}
  csum = Sum a -> a
forall a. Sum a -> a
getSum (Sum a -> a) -> (f a -> Sum a) -> f a -> a
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (a -> Sum a) -> f a -> Sum a
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> Sum a
forall a. a -> Sum a
Sum

  cproduct :: (Num a, Dom f a) => f a -> a
  {-# INLINE [1] cproduct #-}
  cproduct = Product a -> a
forall a. Product a -> a
getProduct (Product a -> a) -> (f a -> Product a) -> f a -> a
forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
#. (a -> Product a) -> f a -> Product a
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> Product a
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 = (a -> g () -> g ()) -> g () -> f a -> g ()
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> g () -> g ()
c (() -> g ()
forall a. Dom g a => a -> g a
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 g b -> g () -> g ()
forall a b. (Dom g a, Dom g b) => g a -> g b -> g b
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 = (a -> g () -> g ()) -> g () -> f a -> g ()
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
forall (f :: * -> *) a b.
(CFoldable f, Dom f a) =>
(a -> b -> b) -> b -> f a -> b
cfoldr a -> g () -> g ()
c (() -> g ()
forall a. a -> g a
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 g b -> g () -> g ()
forall a b. g a -> g b -> g b
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 = Maybe a -> a
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe a -> a) -> (f a -> Maybe a) -> f a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handler (f a) a -> Fold a (Maybe a) -> f a -> Maybe a
forall s a b. Handler s a -> Fold a b -> s -> b
L.foldOver (a -> Const (Dual (Endo x)) a)
-> f a -> Const (Dual (Endo x)) (f a)
Handler (f a) a
forall (f :: * -> *).
(Contravariant f, Applicative f) =>
(a -> f a) -> f a -> f (f a)
forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded Fold a (Maybe a)
forall a. Fold a (Maybe a)
L.last

  chead :: Dom f a => f a -> a
  {-# INLINE [1] chead #-}
  chead = Maybe a -> a
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe a -> a) -> (f a -> Maybe a) -> f a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handler (f a) a -> Fold a (Maybe a) -> f a -> Maybe a
forall s a b. Handler s a -> Fold a b -> s -> b
L.foldOver (a -> Const (Dual (Endo x)) a)
-> f a -> Const (Dual (Endo x)) (f a)
Handler (f a) a
forall (f :: * -> *).
(Contravariant f, Applicative f) =>
(a -> f a) -> f a -> f (f a)
forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded Fold a (Maybe a)
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 -> First a -> Maybe a
forall a. First a -> Maybe a
getFirst (First a -> Maybe a) -> (f a -> First a) -> f a -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> First a) -> f a -> First a
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (\a
x -> Maybe a -> First a
forall a. Maybe a -> First a
First (Maybe a -> First a) -> Maybe a -> First a
forall a b. (a -> b) -> a -> b
$ if a -> Bool
p a
x then a -> Maybe a
forall a. a -> Maybe a
Just a
x else Maybe a
forall a. Maybe a
Nothing)

  cfindIndex :: Dom f a => (a -> Bool) -> f a -> Maybe Int
  {-# INLINE [1] cfindIndex #-}
  cfindIndex = Handler (f a) a -> Fold a (Maybe Int) -> f a -> Maybe Int
forall s a b. Handler s a -> Fold a b -> s -> b
L.foldOver (a -> Const (Dual (Endo x)) a)
-> f a -> Const (Dual (Endo x)) (f a)
Handler (f a) a
forall (f :: * -> *).
(Contravariant f, Applicative f) =>
(a -> f a) -> f a -> f (f a)
forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded (Fold a (Maybe Int) -> f a -> Maybe Int)
-> ((a -> Bool) -> Fold a (Maybe Int))
-> (a -> Bool)
-> f a
-> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Fold a (Maybe Int)
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 -> (a -> Bool) -> [a] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
List.findIndices a -> Bool
p ([a] -> [Int]) -> (f a -> [a]) -> f a -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 = (a -> Bool) -> f a -> Maybe Int
forall a. Dom f a => (a -> Bool) -> f a -> Maybe Int
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Maybe Int
cfindIndex ((a -> Bool) -> f a -> Maybe Int)
-> (a -> a -> Bool) -> a -> f a -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==)

  celemIndices :: (Dom f a, Eq a) => a -> f a -> [Int]
  {-# INLINE [0] celemIndices #-}
  celemIndices = (a -> Bool) -> f a -> [Int]
forall a. Dom f a => (a -> Bool) -> f a -> [Int]
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> [Int]
cfindIndices ((a -> Bool) -> f a -> [Int])
-> (a -> a -> Bool) -> a -> f a -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> Bool
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 = (a -> g b) -> WrapFunctor f a -> g (WrapFunctor f b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WrapFunctor f a -> f (WrapFunctor f b)
traverse
  {-# INLINE [1] ctraverse #-}

instance Foldable f => CFoldable (WrapFunctor f) where
  cfoldMap :: forall a w.
(Dom (WrapFunctor f) a, Monoid w) =>
(a -> w) -> WrapFunctor f a -> w
cfoldMap = (a -> w) -> WrapFunctor f a -> w
forall m a. Monoid m => (a -> m) -> WrapFunctor f a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap
  {-# INLINE [1] cfoldMap #-}
  cfoldMap' :: forall a w.
(Dom (WrapFunctor f) a, Monoid w) =>
(a -> w) -> WrapFunctor f a -> w
cfoldMap' = (a -> m) -> WrapFunctor f a -> m
forall m a. Monoid m => (a -> m) -> WrapFunctor f a -> m
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 = WrapFunctor f w -> w
forall m. Monoid m => WrapFunctor f m -> m
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 = (a -> b -> b) -> b -> WrapFunctor f a -> b
forall a b. (a -> b -> b) -> b -> WrapFunctor f a -> b
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' = (a -> b -> b) -> b -> WrapFunctor f a -> b
forall a b. (a -> b -> b) -> b -> WrapFunctor f a -> b
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 = (b -> a -> b) -> b -> WrapFunctor f a -> b
forall b a. (b -> a -> b) -> b -> WrapFunctor f a -> b
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' = (b -> a -> b) -> b -> WrapFunctor f a -> b
forall b a. (b -> a -> b) -> b -> WrapFunctor f a -> b
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 = WrapFunctor f a -> [a]
forall a. WrapFunctor f a -> [a]
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 = (a -> a -> a) -> WrapFunctor f a -> a
forall a. (a -> a -> a) -> WrapFunctor f a -> a
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 = (a -> a -> a) -> WrapFunctor f a -> a
forall a. (a -> a -> a) -> WrapFunctor f a -> a
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 = (a -> b -> m a) -> a -> WrapFunctor f b -> m a
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 = (a -> b -> m b) -> b -> WrapFunctor f a -> m b
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 = WrapFunctor f a -> Bool
forall a. WrapFunctor f a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null
  {-# INLINE [1] cnull #-}
  clength :: forall a. Dom (WrapFunctor f) a => WrapFunctor f a -> Int
clength = WrapFunctor f a -> Int
forall a. WrapFunctor f a -> Int
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 = (a -> Bool) -> WrapFunctor f a -> Bool
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 = (a -> Bool) -> WrapFunctor f a -> Bool
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 = a -> WrapFunctor f a -> Bool
forall a. Eq a => a -> WrapFunctor f a -> Bool
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 = a -> WrapFunctor f a -> Bool
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 = WrapFunctor f a -> a
forall a. Ord a => WrapFunctor f a -> a
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 = WrapFunctor f a -> a
forall a. Ord a => WrapFunctor f a -> a
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 = WrapFunctor f a -> a
forall a. Num a => WrapFunctor f a -> a
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 = WrapFunctor f a -> a
forall a. Num a => WrapFunctor f a -> a
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_ = (a -> g b) -> WrapFunctor f a -> g ()
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 = (a -> Bool) -> WrapFunctor f a -> Maybe a
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 = Fold a (Maybe Int) -> WrapFunctor f a -> Maybe Int
forall (f :: * -> *) a b. Foldable f => Fold a b -> f a -> b
L.fold (Fold a (Maybe Int) -> WrapFunctor f a -> Maybe Int)
-> ((a -> Bool) -> Fold a (Maybe Int))
-> (a -> Bool)
-> WrapFunctor f a
-> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Fold a (Maybe Int)
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 = Fold a (Maybe Int) -> WrapFunctor f a -> Maybe Int
forall (f :: * -> *) a b. Foldable f => Fold a b -> f a -> b
L.fold (Fold a (Maybe Int) -> WrapFunctor f a -> Maybe Int)
-> (a -> Fold a (Maybe Int)) -> a -> WrapFunctor f a -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Fold a (Maybe Int)
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
  -- | __N.B.__ If we require @g@ to be 'CApplicative'
  --   we cannot directly lift plain 'Traversable' to 'CTraversable'.
  --   This is rather annoying, so we require the strongest possible
  --   constraint to @g@ here.
  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 = (a -> g b) -> [a] -> g [b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [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 = (a -> g b) -> Maybe a -> g (Maybe b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe 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 = (a -> g b) -> Either e a -> g (Either e b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Either e a -> f (Either e 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 = (a -> g b) -> IntMap a -> g (IntMap b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IntMap a -> f (IntMap 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 = (a -> g b) -> Map k a -> g (Map k b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Map k a -> f (Map k 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 = (a -> g b) -> HashMap k a -> g (HashMap k b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> HashMap k a -> f (HashMap k 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 = (a -> g b) -> Seq a -> g (Seq b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Seq a -> f (Seq 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 = (a -> g b) -> Par1 a -> g (Par1 b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Par1 a -> f (Par1 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 = (a -> g b) -> NonEmpty a -> g (NonEmpty b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NonEmpty a -> f (NonEmpty 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 = (a -> g b) -> Down a -> g (Down b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Down a -> f (Down 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 = (a -> g b) -> Last a -> g (Last b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Last a -> f (Last 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 = (a -> g b) -> First a -> g (First b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> First a -> f (First 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 = (a -> g b) -> Last a -> g (Last b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Last a -> f (Last 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 = (a -> g b) -> First a -> g (First b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> First a -> f (First 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 = (a -> g b) -> Identity a -> g (Identity b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Identity a -> f (Identity 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 = (a -> g b) -> ZipList a -> g (ZipList b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ZipList a -> f (ZipList 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 = (a -> g b) -> Min a -> g (Min b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Min a -> f (Min 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 = (a -> g b) -> Max a -> g (Max b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Max a -> f (Max 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 = (a -> g b) -> Complex a -> g (Complex b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Complex a -> f (Complex 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 = (a -> g b) -> V1 a -> g (V1 b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> V1 a -> f (V1 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 = (a -> g b) -> U1 a -> g (U1 b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> U1 a -> f (U1 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 = (a -> g b) -> (a, a) -> g (a, b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> (a, a) -> f (a, 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 = (a -> g b) -> Proxy a -> g (Proxy b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Proxy a -> f (Proxy 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 = (a -> g b) -> Arg a a -> g (Arg a b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Arg a a -> f (Arg a 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 = (a -> g b) -> URec Char a -> g (URec Char b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> URec Char a -> f (URec Char 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 = (a -> g b) -> URec Double a -> g (URec Double b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> URec Double a -> f (URec Double 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 = (a -> g b) -> URec Float a -> g (URec Float b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> URec Float a -> f (URec Float 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 = (a -> g b) -> URec Int a -> g (URec Int b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> URec Int a -> f (URec Int 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 = (a -> g b) -> URec Word a -> g (URec Word b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> URec Word a -> f (URec Word 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 = (a -> g b) -> URec (Ptr ()) a -> g (URec (Ptr ()) b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) 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 = (a -> g b) -> Const m a -> g (Const m b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Const m a -> f (Const m 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 = (a -> g b) -> K1 i c a -> g (K1 i c b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> K1 i c a -> f (K1 i c b)
traverse
  {-# INLINE [1] ctraverse #-}

instance (CFoldable f, CFoldable g) => CFoldable (f :+: g) where
  {-# INLINE [1] cfoldMap #-}
  cfoldMap :: forall a w.
(Dom (f :+: g) a, Monoid w) =>
(a -> w) -> (:+:) f g a -> w
cfoldMap a -> w
f = \case
    L1 f a
x -> (a -> w) -> f a -> w
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
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 -> (a -> w) -> g a -> w
forall a w. (Dom g a, Monoid w) => (a -> w) -> g a -> w
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 -> (a -> b -> b) -> b -> f a -> b
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
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 -> (a -> b -> b) -> b -> g a -> b
forall a b. Dom g a => (a -> b -> b) -> b -> g a -> b
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 w.
(Dom (f :+: g) a, Monoid w) =>
(a -> w) -> (:+:) f g a -> w
cfoldMap' = \a -> m
f -> \case
    L1 f a
x -> (a -> m) -> f a -> m
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
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 -> (a -> m) -> g a -> m
forall a w. (Dom g a, Monoid w) => (a -> w) -> g a -> w
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 -> f w -> w
forall w. (Dom f w, Monoid w) => f w -> w
forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold f w
x
    R1 g w
x -> g w -> w
forall w. (Dom g w, Monoid w) => g w -> w
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 -> (a -> b -> b) -> b -> f a -> b
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
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 -> (a -> b -> b) -> b -> g a -> b
forall a b. Dom g a => (a -> b -> b) -> b -> g a -> b
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 -> (b -> a -> b) -> b -> f a -> b
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
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 -> (b -> a -> b) -> b -> g a -> b
forall a b. Dom g a => (b -> a -> b) -> b -> g a -> b
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 -> (b -> a -> b) -> b -> f a -> b
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
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 -> (b -> a -> b) -> b -> g a -> b
forall a b. Dom g a => (b -> a -> b) -> b -> g a -> b
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 -> f a -> [a]
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList f a
x
    R1 g a
x -> g a -> [a]
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 -> (a -> a -> a) -> f a -> a
forall a. Dom f a => (a -> a -> a) -> f a -> a
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 -> (a -> a -> a) -> g a -> a
forall a. Dom g a => (a -> a -> a) -> g a -> a
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 -> (a -> a -> a) -> f a -> a
forall a. Dom f a => (a -> a -> a) -> f a -> a
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 -> (a -> a -> a) -> g a -> a
forall a. Dom g a => (a -> a -> a) -> g a -> a
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 -> f a -> Bool
forall a. Dom f a => f a -> Bool
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull f a
x
    R1 g a
x -> g a -> Bool
forall a. Dom g a => g a -> Bool
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 -> f a -> Int
forall a. Dom f a => f a -> Int
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength f a
x
    R1 g a
x -> g a -> Int
forall a. Dom g a => g a -> Int
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 -> (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f f a
x
    R1 g a
x -> (a -> Bool) -> g a -> Bool
forall a. Dom g a => (a -> Bool) -> g a -> Bool
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 -> (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f f a
x
    R1 g a
x -> (a -> Bool) -> g a -> Bool
forall a. Dom g a => (a -> Bool) -> g a -> Bool
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 -> a -> f a -> Bool
forall a. (Eq a, Dom f a) => a -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x f a
xs
    R1 g a
xs -> a -> g a -> Bool
forall a. (Eq a, Dom g a) => a -> g a -> Bool
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 -> f a -> a
forall a. (Ord a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cminimum f a
xs
    R1 g a
xs -> g a -> a
forall a. (Ord a, Dom g a) => g a -> a
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 -> f a -> a
forall a. (Ord a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cmaximum f a
xs
    R1 g a
xs -> g a -> a
forall a. (Ord a, Dom g a) => g a -> a
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 -> f a -> a
forall a. (Num a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum f a
xs
    R1 g a
xs -> g a -> a
forall a. (Num a, Dom g a) => g a -> a
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 -> f a -> a
forall a. (Num a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct f a
xs
    R1 g a
xs -> g a -> a
forall a. (Num a, Dom g a) => g a -> a
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 -> (a -> g b) -> f a -> g ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f f a
xs
    R1 g a
xs -> (a -> g b) -> g a -> g ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom g a) =>
(a -> g b) -> g 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 -> f b -> (:+:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (f b -> (:+:) f g b) -> g (f b) -> g ((:+:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> g b) -> f a -> g (f b)
forall a b (g :: * -> *).
(Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (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 -> g b -> (:+:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (g b -> (:+:) f g b) -> g (g b) -> g ((:+:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> g b) -> g a -> g (g b)
forall a b (g :: * -> *).
(Dom g a, Dom g b, Applicative g) =>
(a -> g b) -> g a -> g (g 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 w.
(Dom (f :*: g) a, Monoid w) =>
(a -> w) -> (:*:) f g a -> w
cfoldMap a -> w
f (f a
l :*: g a
r) = (a -> w) -> f a -> w
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f f a
l w -> w -> w
forall a. Semigroup a => a -> a -> a
<> (a -> w) -> g a -> w
forall a w. (Dom g a, Monoid w) => (a -> w) -> g a -> w
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 w.
(Dom (f :*: g) a, Monoid w) =>
(a -> w) -> (:*:) f g a -> w
cfoldMap' a -> m
f (f a
l :*: g a
r) = (a -> m) -> f a -> m
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f f a
l m -> m -> m
forall a. Semigroup a => a -> a -> a
<> (a -> m) -> g a -> m
forall a w. (Dom g a, Monoid w) => (a -> w) -> g a -> w
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) = f w -> w
forall w. (Dom f w, Monoid w) => f w -> w
forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold f w
l w -> w -> w
forall a. Semigroup a => a -> a -> a
<> g w -> w
forall w. (Dom g w, Monoid w) => g w -> w
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) = f a -> Bool
forall a. Dom f a => f a -> Bool
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull f a
l Bool -> Bool -> Bool
&& g a -> Bool
forall a. Dom g a => g a -> 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) = f a -> Int
forall a. Dom f a => f a -> Int
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength f a
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ g a -> Int
forall a. Dom g a => g a -> Int
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) = (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f f a
l Bool -> Bool -> Bool
|| (a -> Bool) -> g a -> Bool
forall a. Dom g a => (a -> Bool) -> g a -> 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) = (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f f a
l Bool -> Bool -> Bool
&& (a -> Bool) -> g a -> Bool
forall a. Dom g a => (a -> Bool) -> g a -> 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) = a -> f a -> Bool
forall a. (Eq a, Dom f a) => a -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x f a
l Bool -> Bool -> Bool
|| a -> g a -> Bool
forall a. (Eq a, Dom g a) => a -> g a -> 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) = f a -> a
forall a. (Num a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum f a
l a -> a -> a
forall a. Num a => a -> a -> a
+ g a -> a
forall a. (Num a, Dom g a) => g 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) = f a -> a
forall a. (Num a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct f a
l a -> a -> a
forall a. Num a => a -> a -> a
* g a -> a
forall a. (Num a, Dom g a) => g 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) = (a -> g b) -> f a -> g ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f f a
l g () -> g () -> g ()
forall a b. g a -> g b -> g b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (a -> g b) -> g a -> g ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom g a) =>
(a -> g b) -> g 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) =
    f b -> g b -> (:*:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (f b -> g b -> (:*:) f g b) -> g (f b) -> g (g b -> (:*:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> g b) -> f a -> g (f b)
forall a b (g :: * -> *).
(Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (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 g (g b -> (:*:) f g b) -> g (g b) -> g ((:*:) f g b)
forall a b. g (a -> b) -> g a -> g b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (a -> g b) -> g a -> g (g b)
forall a b (g :: * -> *).
(Dom g a, Dom g b, Applicative g) =>
(a -> g b) -> g a -> g (g 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 w.
(Dom (Sum f g) a, Monoid w) =>
(a -> w) -> Sum f g a -> w
cfoldMap a -> w
f = \case
    SOP.InL f a
x -> (a -> w) -> f a -> w
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
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 -> (a -> w) -> g a -> w
forall a w. (Dom g a, Monoid w) => (a -> w) -> g a -> w
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 -> (a -> b -> b) -> b -> f a -> b
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
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 -> (a -> b -> b) -> b -> g a -> b
forall a b. Dom g a => (a -> b -> b) -> b -> g a -> b
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 w.
(Dom (Sum f g) a, Monoid w) =>
(a -> w) -> Sum f g a -> w
cfoldMap' = \a -> m
f -> \case
    SOP.InL f a
x -> (a -> m) -> f a -> m
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
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 -> (a -> m) -> g a -> m
forall a w. (Dom g a, Monoid w) => (a -> w) -> g a -> w
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 -> f w -> w
forall w. (Dom f w, Monoid w) => f w -> w
forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold f w
x
    SOP.InR g w
x -> g w -> w
forall w. (Dom g w, Monoid w) => g w -> w
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 -> (a -> b -> b) -> b -> f a -> b
forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b
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 -> (a -> b -> b) -> b -> g a -> b
forall a b. Dom g a => (a -> b -> b) -> b -> g a -> b
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 -> (b -> a -> b) -> b -> f a -> b
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
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 -> (b -> a -> b) -> b -> g a -> b
forall a b. Dom g a => (b -> a -> b) -> b -> g a -> b
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 -> (b -> a -> b) -> b -> f a -> b
forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b
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 -> (b -> a -> b) -> b -> g a -> b
forall a b. Dom g a => (b -> a -> b) -> b -> g a -> b
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 -> f a -> [a]
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList f a
x
    SOP.InR g a
x -> g a -> [a]
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 -> (a -> a -> a) -> f a -> a
forall a. Dom f a => (a -> a -> a) -> f a -> a
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 -> (a -> a -> a) -> g a -> a
forall a. Dom g a => (a -> a -> a) -> g a -> a
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 -> (a -> a -> a) -> f a -> a
forall a. Dom f a => (a -> a -> a) -> f a -> a
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 -> (a -> a -> a) -> g a -> a
forall a. Dom g a => (a -> a -> a) -> g a -> a
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 -> f a -> Bool
forall a. Dom f a => f a -> Bool
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull f a
x
    SOP.InR g a
x -> g a -> Bool
forall a. Dom g a => g a -> Bool
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 -> f a -> Int
forall a. Dom f a => f a -> Int
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength f a
x
    SOP.InR g a
x -> g a -> Int
forall a. Dom g a => g a -> Int
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 -> (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
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 -> (a -> Bool) -> g a -> Bool
forall a. Dom g a => (a -> Bool) -> g a -> Bool
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 -> (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
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 -> (a -> Bool) -> g a -> Bool
forall a. Dom g a => (a -> Bool) -> g a -> Bool
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 -> a -> f a -> Bool
forall a. (Eq a, Dom f a) => a -> f a -> Bool
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 -> a -> g a -> Bool
forall a. (Eq a, Dom g a) => a -> g a -> Bool
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 -> f a -> a
forall a. (Ord a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cminimum f a
xs
    SOP.InR g a
xs -> g a -> a
forall a. (Ord a, Dom g a) => g a -> a
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 -> f a -> a
forall a. (Ord a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Ord a, Dom f a) => f a -> a
cmaximum f a
xs
    SOP.InR g a
xs -> g a -> a
forall a. (Ord a, Dom g a) => g a -> a
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 -> f a -> a
forall a. (Num a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum f a
xs
    SOP.InR g a
xs -> g a -> a
forall a. (Num a, Dom g a) => g a -> a
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 -> f a -> a
forall a. (Num a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct f a
xs
    SOP.InR g a
xs -> g a -> a
forall a. (Num a, Dom g a) => g a -> a
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 -> (a -> g b) -> f a -> g ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f f a
xs
    SOP.InR g a
xs -> (a -> g b) -> g a -> g ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom g a) =>
(a -> g b) -> g 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 -> f b -> Sum f g b
forall {k} (f :: k -> *) (g :: k -> *) (a :: k). f a -> Sum f g a
SOP.InL (f b -> Sum f g b) -> g (f b) -> g (Sum f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> g b) -> f a -> g (f b)
forall a b (g :: * -> *).
(Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (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 -> g b -> Sum f g b
forall {k} (f :: k -> *) (g :: k -> *) (a :: k). g a -> Sum f g a
SOP.InR (g b -> Sum f g b) -> g (g b) -> g (Sum f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> g b) -> g a -> g (g b)
forall a b (g :: * -> *).
(Dom g a, Dom g b, Applicative g) =>
(a -> g b) -> g a -> g (g 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 w.
(Dom (Product f g) a, Monoid w) =>
(a -> w) -> Product f g a -> w
cfoldMap a -> w
f (SOP.Pair f a
l g a
r) = (a -> w) -> f a -> w
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap a -> w
f f a
l w -> w -> w
forall a. Semigroup a => a -> a -> a
<> (a -> w) -> g a -> w
forall a w. (Dom g a, Monoid w) => (a -> w) -> g a -> w
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 w.
(Dom (Product f g) a, Monoid w) =>
(a -> w) -> Product f g a -> w
cfoldMap' a -> m
f (SOP.Pair f a
l g a
r) = (a -> m) -> f a -> m
forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap' a -> m
f f a
l m -> m -> m
forall a. Semigroup a => a -> a -> a
<> (a -> m) -> g a -> m
forall a w. (Dom g a, Monoid w) => (a -> w) -> g a -> w
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) = f w -> w
forall w. (Dom f w, Monoid w) => f w -> w
forall (f :: * -> *) w.
(CFoldable f, Dom f w, Monoid w) =>
f w -> w
cfold f w
l w -> w -> w
forall a. Semigroup a => a -> a -> a
<> g w -> w
forall w. (Dom g w, Monoid w) => g w -> w
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) = f a -> Bool
forall a. Dom f a => f a -> Bool
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Bool
cnull f a
l Bool -> Bool -> Bool
&& g a -> Bool
forall a. Dom g a => g a -> 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) = f a -> Int
forall a. Dom f a => f a -> Int
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> Int
clength f a
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ g a -> Int
forall a. Dom g a => g a -> Int
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) = (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
cany a -> Bool
f f a
l Bool -> Bool -> Bool
|| (a -> Bool) -> g a -> Bool
forall a. Dom g a => (a -> Bool) -> g a -> 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) = (a -> Bool) -> f a -> Bool
forall a. Dom f a => (a -> Bool) -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Dom f a) =>
(a -> Bool) -> f a -> Bool
call a -> Bool
f f a
l Bool -> Bool -> Bool
&& (a -> Bool) -> g a -> Bool
forall a. Dom g a => (a -> Bool) -> g a -> 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) = a -> f a -> Bool
forall a. (Eq a, Dom f a) => a -> f a -> Bool
forall (f :: * -> *) a.
(CFoldable f, Eq a, Dom f a) =>
a -> f a -> Bool
celem a
x f a
l Bool -> Bool -> Bool
|| a -> g a -> Bool
forall a. (Eq a, Dom g a) => a -> g a -> 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) = f a -> a
forall a. (Num a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
csum f a
l a -> a -> a
forall a. Num a => a -> a -> a
+ g a -> a
forall a. (Num a, Dom g a) => g 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) = f a -> a
forall a. (Num a, Dom f a) => f a -> a
forall (f :: * -> *) a. (CFoldable f, Num a, Dom f a) => f a -> a
cproduct f a
l a -> a -> a
forall a. Num a => a -> a -> a
* g a -> a
forall a. (Num a, Dom g a) => g 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) =
    (a -> g b) -> f a -> g ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
ctraverse_ a -> g b
f f a
l g () -> g () -> g ()
forall a b. g a -> g b -> g b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (a -> g b) -> g a -> g ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom g a) =>
(a -> g b) -> g 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 = (a -> b -> b) -> b -> PrimArray a -> b
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' = (b -> a -> b) -> b -> PrimArray a -> b
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' = (a -> b -> m a) -> a -> PrimArray b -> m a
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 = (b -> a -> b) -> b -> PrimArray a -> b
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 = PrimArray a -> Int
forall a. Prim a => PrimArray a -> Int
PA.sizeofPrimArray
  {-# INLINE [1] clength #-}
  csum :: forall a. (Num a, Dom PrimArray a) => PrimArray a -> a
csum = (a -> a -> a) -> a -> PrimArray a -> a
forall a b. Prim a => (b -> a -> b) -> b -> PrimArray a -> b
PA.foldlPrimArray' a -> a -> a
forall a. Num a => a -> a -> a
(+) a
0
  {-# INLINE [1] csum #-}
  cproduct :: forall a. (Num a, Dom PrimArray a) => PrimArray a -> a
cproduct = (a -> a -> a) -> a -> PrimArray a -> a
forall a b. Prim a => (b -> a -> b) -> b -> PrimArray a -> b
PA.foldlPrimArray' a -> a -> a
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_ = (a -> g b) -> PrimArray a -> g ()
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 = (a -> g b) -> PrimArray a -> g (PrimArray b)
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 = (a -> g b) -> SmallArray a -> g (SmallArray b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SmallArray a -> f (SmallArray 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 = (a -> g b) -> Array a -> g (Array b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Array a -> f (Array 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) =
    f b -> g b -> Product f g b
forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
SOP.Pair (f b -> g b -> Product f g b)
-> g (f b) -> g (g b -> Product f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> g b) -> f a -> g (f b)
forall a b (g :: * -> *).
(Dom f a, Dom f b, Applicative g) =>
(a -> g b) -> f a -> g (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 g (g b -> Product f g b) -> g (g b) -> g (Product f g b)
forall a b. g (a -> b) -> g a -> g b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (a -> g b) -> g a -> g (g b)
forall a b (g :: * -> *).
(Dom g a, Dom g b, Applicative g) =>
(a -> g b) -> g a -> g (g 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 w. (Dom Set a, Monoid w) => (a -> w) -> Set a -> w
cfoldMap = (a -> w) -> Set a -> w
(Element (Set a) -> w) -> Set a -> w
forall m. Monoid m => (Element (Set a) -> m) -> Set a -> m
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 = (a -> b -> b) -> b -> Set a -> b
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 = (b -> a -> b) -> b -> Set a -> b
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' = (a -> b -> b) -> b -> Set a -> b
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' = (b -> a -> b) -> b -> Set a -> b
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 = Set a -> a
forall a. Set a -> a
Set.findMin
  {-# INLINE [1] cminimum #-}
  cmaximum :: forall a. (Ord a, Dom Set a) => Set a -> a
cmaximum = Set a -> a
forall a. Set a -> a
Set.findMax
  {-# INLINE [1] cmaximum #-}
  celem :: forall a. (Eq a, Dom Set a) => a -> Set a -> Bool
celem = a -> Set a -> Bool
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 = a -> Set a -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.notMember
  {-# INLINE [1] cnotElem #-}
  cbasicToList :: forall a. Dom Set a => Set a -> [a]
cbasicToList = Set a -> [a]
forall a. Set a -> [a]
Set.toList
  {-# INLINE cbasicToList #-}
  celemIndex :: forall a. (Dom Set a, Eq a) => a -> Set a -> Maybe Int
celemIndex = a -> Set a -> Maybe Int
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 = (Int -> Set a -> a) -> Set a -> Int -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> Set a -> a
forall a. Int -> Set a -> a
Set.elemAt
  {-# INLINE [1] cindex #-}

instance CTraversable Set.Set where
  -- TODO: more efficient implementation
  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 =
      ([b] -> Set b) -> g [b] -> g (Set b)
forall a b. (a -> b) -> g a -> g b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [b] -> Set b
forall a. Ord a => [a] -> Set a
Set.fromList
    (g [b] -> g (Set b)) -> (Set a -> g [b]) -> Set a -> g (Set b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> g b) -> [a] -> g [b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse a -> g b
f
    ([a] -> g [b]) -> (Set a -> [a]) -> Set a -> g [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set a -> [a]
forall a. Set a -> [a]
Set.toList
  {-# INLINE [1] ctraverse #-}

instance CFoldable HS.HashSet where
  cfoldMap :: forall a w. (Dom HashSet a, Monoid w) => (a -> w) -> HashSet a -> w
cfoldMap = (a -> w) -> HashSet a -> w
(Element (HashSet a) -> w) -> HashSet a -> w
forall m. Monoid m => (Element (HashSet a) -> m) -> HashSet a -> m
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 = (a -> b -> b) -> b -> HashSet a -> b
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' = (b -> a -> b) -> b -> HashSet a -> b
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 = a -> HashSet a -> Bool
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 = HashSet a -> [a]
forall a. HashSet a -> [a]
HS.toList
  {-# INLINE cbasicToList #-}

instance CTraversable HS.HashSet where
  -- TODO: more efficient implementation
  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 =
      ([b] -> HashSet b) -> g [b] -> g (HashSet b)
forall a b. (a -> b) -> g a -> g b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [b] -> HashSet b
forall a. (Eq a, Hashable a) => [a] -> HashSet a
HS.fromList
    (g [b] -> g (HashSet b))
-> (HashSet a -> g [b]) -> HashSet a -> g (HashSet b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> g b) -> [a] -> g [b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse a -> g b
f
    ([a] -> g [b]) -> (HashSet a -> [a]) -> HashSet a -> g [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashSet a -> [a]
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 w.
(Dom (WrapMono mono) a, Monoid w) =>
(a -> w) -> WrapMono mono a -> w
cfoldMap = (a -> w) -> WrapMono mono a -> w
(Element (WrapMono mono a) -> w) -> WrapMono mono a -> w
forall m.
Monoid m =>
(Element (WrapMono mono a) -> m) -> WrapMono mono a -> m
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 = WrapMono mono w -> w
WrapMono mono w -> Element (WrapMono mono w)
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 = (a -> b -> b) -> b -> WrapMono mono a -> b
(Element (WrapMono mono a) -> b -> b) -> b -> WrapMono mono a -> b
forall mono b.
MonoFoldable mono =>
(Element mono -> b -> b) -> b -> mono -> b
forall b.
(Element (WrapMono mono a) -> b -> b) -> b -> WrapMono mono a -> b
ofoldr
  {-# INLINE [1] cfoldr #-}
  cfoldl' :: forall a b.
Dom (WrapMono mono) a =>
(b -> a -> b) -> b -> WrapMono mono a -> b
cfoldl' = (b -> a -> b) -> b -> WrapMono mono a -> b
(b -> Element (WrapMono mono a) -> b) -> b -> WrapMono mono a -> b
forall mono a.
MonoFoldable mono =>
(a -> Element mono -> a) -> a -> mono -> a
forall a.
(a -> Element (WrapMono mono a) -> a) -> a -> WrapMono mono a -> 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 = (a -> b -> m a) -> a -> WrapMono mono b -> m a
(a -> Element (WrapMono mono b) -> m a)
-> a -> WrapMono mono b -> m a
forall mono (m :: * -> *) a.
(MonoFoldable mono, Monad m) =>
(a -> Element mono -> m a) -> a -> mono -> m a
forall (m :: * -> *) a.
Monad m =>
(a -> Element (WrapMono mono b) -> m a)
-> a -> WrapMono mono b -> m a
ofoldlM
  {-# INLINE [1] cfoldlM #-}
  cbasicToList :: forall a. Dom (WrapMono mono) a => WrapMono mono a -> [a]
cbasicToList = WrapMono mono a -> [a]
WrapMono mono a -> [Element (WrapMono mono a)]
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 = (a -> a -> a) -> WrapMono mono a -> a
(Element (WrapMono mono a)
 -> Element (WrapMono mono a) -> Element (WrapMono mono a))
-> WrapMono mono a -> Element (WrapMono mono a)
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 = WrapMono mono a -> Bool
forall mono. MonoFoldable mono => mono -> Bool
onull
  {-# INLINE [1] cnull #-}
  clength :: forall a. Dom (WrapMono mono) a => WrapMono mono a -> Int
clength = WrapMono mono a -> Int
forall mono. MonoFoldable mono => mono -> Int
olength
  {-# INLINE [1] clength #-}
  cany :: forall a.
Dom (WrapMono mono) a =>
(a -> Bool) -> WrapMono mono a -> Bool
cany = (a -> Bool) -> WrapMono mono a -> Bool
(Element (WrapMono mono a) -> Bool) -> WrapMono mono a -> Bool
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 = (a -> Bool) -> WrapMono mono a -> Bool
(Element (WrapMono mono a) -> Bool) -> WrapMono mono a -> Bool
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 = a -> WrapMono mono a -> Bool
Element (WrapMono mono a) -> WrapMono mono a -> Bool
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 = a -> WrapMono mono a -> Bool
Element (WrapMono mono a) -> WrapMono mono a -> Bool
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 = WrapMono mono a -> a
WrapMono mono a -> Element (WrapMono mono a)
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 = WrapMono mono a -> a
WrapMono mono a -> Element (WrapMono mono a)
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 = WrapMono mono a -> a
WrapMono mono a -> Element (WrapMono mono a)
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 = WrapMono mono a -> a
WrapMono mono a -> Element (WrapMono mono a)
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_ = (a -> g b) -> WrapMono mono a -> g ()
(Element (WrapMono mono a) -> g b) -> WrapMono mono a -> g ()
forall mono (f :: * -> *) b.
(MonoFoldable mono, Applicative f) =>
(Element mono -> f b) -> mono -> f ()
forall (f :: * -> *) b.
Applicative f =>
(Element (WrapMono mono a) -> f b) -> WrapMono mono a -> 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 -> (mono -> WrapMono mono b) -> g mono -> g (WrapMono mono b)
forall a b. (a -> b) -> g a -> g b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap mono -> WrapMono mono b
forall b mono.
(b ~ Element mono, b ~ Element mono) =>
mono -> WrapMono mono b
WrapMono (g mono -> g (WrapMono mono b))
-> (WrapMono mono a -> g mono)
-> WrapMono mono a
-> g (WrapMono mono b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element mono -> g (Element mono)) -> mono -> g mono
forall mono (f :: * -> *).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
forall (f :: * -> *).
Applicative f =>
(Element mono -> f (Element mono)) -> mono -> f mono
otraverse a -> g b
Element mono -> g (Element mono)
f (mono -> g mono)
-> (WrapMono mono a -> mono) -> WrapMono mono a -> g mono
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapMono mono a -> mono
forall b mono. (b ~ Element mono) => WrapMono mono b -> mono
unwrapMono

instance CFoldable V.Vector where
  {-# INLINE [1] cfoldMap #-}
  cfoldMap :: forall a w. (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w
cfoldMap = (a -> w) -> Vector a -> w
forall m a. Monoid m => (a -> m) -> Vector a -> m
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 = (a -> b -> b) -> b -> Vector a -> b
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' = (a -> b -> b) -> b -> Vector a -> b
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 = (b -> a -> b) -> b -> Vector a -> b
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' = (b -> a -> b) -> b -> Vector a -> b
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 = (a -> b -> m a) -> a -> Vector b -> m a
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' = (a -> b -> m a) -> a -> Vector b -> m a
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 = Vector a -> Int -> a
forall a. Vector a -> Int -> a
(V.!)
  {-# INLINE [1] celem #-}
  celem :: forall a. (Eq a, Dom Vector a) => a -> Vector a -> Bool
celem = a -> Vector a -> Bool
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 = a -> Vector a -> Bool
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 = (a -> Bool) -> Vector a -> Bool
forall a. (a -> Bool) -> Vector a -> Bool
V.any
  {-# INLINE [1] call #-}
  call :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Bool
call = (a -> Bool) -> Vector a -> Bool
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 = (a -> a -> a) -> Vector a -> a
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 = (a -> a -> a) -> Vector a -> a
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 = Vector a -> a
forall a. Num a => Vector a -> a
V.sum
  {-# INLINE [1] cproduct #-}
  cproduct :: forall a. (Num a, Dom Vector a) => Vector a -> a
cproduct = Vector a -> a
forall a. Num a => Vector a -> a
V.product
  {-# INLINE [1] cmaximum #-}
  cmaximum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cmaximum = Vector a -> a
forall a. Ord a => Vector a -> a
V.maximum
  {-# INLINE [1] cminimum #-}
  cminimum :: forall a. (Ord a, Dom Vector a) => Vector a -> a
cminimum = Vector a -> a
forall a. Ord a => Vector a -> a
V.minimum
  {-# INLINE cbasicToList #-}
  cbasicToList :: forall a. Dom Vector a => Vector a -> [a]
cbasicToList = Vector a -> [a]
forall a. Vector a -> [a]
V.toList
  {-# INLINE [1] clast #-}
  clast :: forall a. Dom Vector a => Vector a -> a
clast = Vector a -> a
forall a. Vector a -> a
V.last
  {-# INLINE [1] chead #-}
  chead :: forall a. Dom Vector a => Vector a -> a
chead = Vector a -> a
forall a. Vector a -> a
V.head
  {-# INLINE [1] cfind #-}
  cfind :: forall a. Dom Vector a => (a -> Bool) -> Vector a -> Maybe a
cfind = (a -> Bool) -> Vector a -> Maybe a
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 = (a -> Bool) -> Vector a -> Maybe Int
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 = (Vector Int -> [Int])
-> (Vector a -> Vector Int) -> Vector a -> [Int]
forall a b. (a -> b) -> (Vector a -> a) -> Vector a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector Int -> [Int]
forall a. Vector a -> [a]
V.toList ((Vector a -> Vector Int) -> Vector a -> [Int])
-> ((a -> Bool) -> Vector a -> Vector Int)
-> (a -> Bool)
-> Vector a
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Vector a -> Vector Int
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 = a -> Vector a -> Maybe Int
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 = (Vector Int -> [Int])
-> (Vector a -> Vector Int) -> Vector a -> [Int]
forall a b. (a -> b) -> (Vector a -> a) -> Vector a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector Int -> [Int]
forall a. Vector a -> [a]
V.toList ((Vector a -> Vector Int) -> Vector a -> [Int])
-> (a -> Vector a -> Vector Int) -> a -> Vector a -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Vector a -> Vector Int
forall a. Eq a => a -> Vector a -> Vector Int
V.elemIndices

instance CFoldable U.Vector where
  {-# INLINE [1] cfoldMap #-}
  cfoldMap :: forall a w. (Dom Vector a, Monoid w) => (a -> w) -> Vector a -> w
cfoldMap = (a -> w) -> Vector a -> w
(Element (Vector a) -> w) -> Vector a -> w
forall m. Monoid m => (Element (Vector a) -> m) -> Vector a -> m
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 = (a -> b -> b) -> b -> Vector a -> b
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' = (a -> b -> b) -> b -> Vector a -> b
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 = (b -> a -> b) -> b -> Vector a -> b
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' = (b -> a -> b) -> b -> Vector a -> b
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 = (a -> b -> m a) -> a -> Vector b -> m a
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' = (a -> b -> m a) -> a -> Vector b -> m a
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 = Vector a -> Int -> a
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 = a -> Vector a -> Bool
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 = a -> Vector a -> Bool
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 = (a -> Bool) -> Vector a -> Bool
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 = (a -> Bool) -> Vector a -> Bool
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 = (a -> a -> a) -> Vector a -> a
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 = (a -> a -> a) -> Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
forall a. (Unbox a, Ord a) => Vector a -> a
U.minimum
  {-# INLINE cbasicToList #-}
  cbasicToList :: forall a. Dom Vector a => Vector a -> [a]
cbasicToList = Vector a -> [a]
forall a. Unbox a => Vector a -> [a]
U.toList
  {-# INLINE [1] clast #-}
  clast :: forall a. Dom Vector a => Vector a -> a
clast = Vector a -> a
forall a. Unbox a => Vector a -> a
U.last
  {-# INLINE [1] chead #-}
  chead :: forall a. Dom Vector a => Vector a -> a
chead = Vector a -> a
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 = (a -> Bool) -> Vector a -> Maybe a
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 = (a -> Bool) -> Vector a -> Maybe Int
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 = (Vector Int -> [Int])
-> (Vector a -> Vector Int) -> Vector a -> [Int]
forall a b. (a -> b) -> (Vector a -> a) -> Vector a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector Int -> [Int]
forall a. Unbox a => Vector a -> [a]
U.toList ((Vector a -> Vector Int) -> Vector a -> [Int])
-> ((a -> Bool) -> Vector a -> Vector Int)
-> (a -> Bool)
-> Vector a
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Vector a -> Vector Int
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 = a -> Vector a -> Maybe Int
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 = (Vector Int -> [Int])
-> (Vector a -> Vector Int) -> Vector a -> [Int]
forall a b. (a -> b) -> (Vector a -> a) -> Vector a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector Int -> [Int]
forall a. Unbox a => Vector a -> [a]
U.toList ((Vector a -> Vector Int) -> Vector a -> [Int])
-> (a -> Vector a -> Vector Int) -> a -> Vector a -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Vector a -> Vector Int
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 = (a -> b -> b) -> b -> Vector a -> b
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' = (a -> b -> b) -> b -> Vector a -> b
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 = (b -> a -> b) -> b -> Vector a -> b
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' = (b -> a -> b) -> b -> Vector a -> b
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 = (a -> b -> m a) -> a -> Vector b -> m a
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' = (a -> b -> m a) -> a -> Vector b -> m a
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 = Vector a -> Int -> a
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 = a -> Vector a -> Bool
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 = a -> Vector a -> Bool
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 = (a -> Bool) -> Vector a -> Bool
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 = (a -> Bool) -> Vector a -> Bool
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 = (a -> a -> a) -> Vector a -> a
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 = (a -> a -> a) -> Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
forall a. (Storable a, Ord a) => Vector a -> a
S.minimum
  {-# INLINE cbasicToList #-}
  cbasicToList :: forall a. Dom Vector a => Vector a -> [a]
cbasicToList = Vector a -> [a]
forall a. Storable a => Vector a -> [a]
S.toList
  {-# INLINE [1] clast #-}
  clast :: forall a. Dom Vector a => Vector a -> a
clast = Vector a -> a
forall a. Storable a => Vector a -> a
S.last
  {-# INLINE [1] chead #-}
  chead :: forall a. Dom Vector a => Vector a -> a
chead = Vector a -> a
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 = (a -> Bool) -> Vector a -> Maybe a
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 = (a -> Bool) -> Vector a -> Maybe Int
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 = (Vector Int -> [Int])
-> (Vector a -> Vector Int) -> Vector a -> [Int]
forall a b. (a -> b) -> (Vector a -> a) -> Vector a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector Int -> [Int]
forall a. Storable a => Vector a -> [a]
S.toList ((Vector a -> Vector Int) -> Vector a -> [Int])
-> ((a -> Bool) -> Vector a -> Vector Int)
-> (a -> Bool)
-> Vector a
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Vector a -> Vector Int
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 = a -> Vector a -> Maybe Int
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 = (Vector Int -> [Int])
-> (Vector a -> Vector Int) -> Vector a -> [Int]
forall a b. (a -> b) -> (Vector a -> a) -> Vector a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector Int -> [Int]
forall a. Storable a => Vector a -> [a]
S.toList ((Vector a -> Vector Int) -> Vector a -> [Int])
-> (a -> Vector a -> Vector Int) -> a -> Vector a -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Vector a -> Vector Int
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 = (a -> b -> b) -> b -> Vector a -> b
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' = (a -> b -> b) -> b -> Vector a -> b
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 = (b -> a -> b) -> b -> Vector a -> b
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' = (b -> a -> b) -> b -> Vector a -> b
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 = (a -> b -> m a) -> a -> Vector b -> m a
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' = (a -> b -> m a) -> a -> Vector b -> m a
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 = Vector a -> Int -> a
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 = a -> Vector a -> Bool
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 = a -> Vector a -> Bool
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 = (a -> Bool) -> Vector a -> Bool
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 = (a -> Bool) -> Vector a -> Bool
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 = (a -> a -> a) -> Vector a -> a
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 = (a -> a -> a) -> Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
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 = Vector a -> a
forall a. (Prim a, Ord a) => Vector a -> a
P.minimum
  {-# INLINE cbasicToList #-}
  cbasicToList :: forall a. Dom Vector a => Vector a -> [a]
cbasicToList = Vector a -> [a]
forall a. Prim a => Vector a -> [a]
P.toList
  {-# INLINE [1] clast #-}
  clast :: forall a. Dom Vector a => Vector a -> a
clast = Vector a -> a
forall a. Prim a => Vector a -> a
P.last
  {-# INLINE [1] chead #-}
  chead :: forall a. Dom Vector a => Vector a -> a
chead = Vector a -> a
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 = (a -> Bool) -> Vector a -> Maybe a
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 = (a -> Bool) -> Vector a -> Maybe Int
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 = (Vector Int -> [Int])
-> (Vector a -> Vector Int) -> Vector a -> [Int]
forall a b. (a -> b) -> (Vector a -> a) -> Vector a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector Int -> [Int]
forall a. Prim a => Vector a -> [a]
P.toList ((Vector a -> Vector Int) -> Vector a -> [Int])
-> ((a -> Bool) -> Vector a -> Vector Int)
-> (a -> Bool)
-> Vector a
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Vector a -> Vector Int
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 = a -> Vector a -> Maybe Int
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 = (Vector Int -> [Int])
-> (Vector a -> Vector Int) -> Vector a -> [Int]
forall a b. (a -> b) -> (Vector a -> a) -> Vector a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector Int -> [Int]
forall a. Prim a => Vector a -> [a]
P.toList ((Vector a -> Vector Int) -> Vector a -> [Int])
-> (a -> Vector a -> Vector Int) -> a -> Vector a -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Vector a -> Vector Int
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 = (a -> g b) -> Vector a -> g (Vector b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector a -> f (Vector 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 -> (Vector b -> Vector b) -> g (Vector b) -> g (Vector b)
forall a b. (a -> b) -> g a -> g b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
S.convert (g (Vector b) -> g (Vector b))
-> (Vector a -> g (Vector b)) -> Vector a -> g (Vector b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> g b) -> Vector a -> g (Vector b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector a -> f (Vector b)
traverse a -> g b
f (Vector a -> g (Vector b))
-> (Vector a -> Vector a) -> Vector a -> g (Vector b)
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 -> (Vector b -> Vector b) -> g (Vector b) -> g (Vector b)
forall a b. (a -> b) -> g a -> g b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
S.convert (g (Vector b) -> g (Vector b))
-> (Vector a -> g (Vector b)) -> Vector a -> g (Vector b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> g b) -> Vector a -> g (Vector b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector a -> f (Vector b)
traverse a -> g b
f (Vector a -> g (Vector b))
-> (Vector a -> Vector a) -> Vector a -> g (Vector b)
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 -> (Vector b -> Vector b) -> g (Vector b) -> g (Vector b)
forall a b. (a -> b) -> g a -> g b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
P.convert (g (Vector b) -> g (Vector b))
-> (Vector a -> g (Vector b)) -> Vector a -> g (Vector b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> g b) -> Vector a -> g (Vector b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector a -> f (Vector b)
traverse a -> g b
f (Vector a -> g (Vector b))
-> (Vector a -> Vector a) -> Vector a -> g (Vector b)
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
  #-}
-- | Free monoid functor from fullsubcategory.
--   It must be a pointed foldable functor with the property
--   that for any 'Monoid' @w@ and @f :: a -> w@,
--   @'cfoldMap' f@ must be a monoid homomorphism and the following
--   must be hold:
--
--    @
--       'cfoldMap' f . 'cpure' == f
--    @
--
--   Hence, @'Set's@ cannot be a free monoid functor;
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 = (a -> f a -> f a) -> f a -> [a] -> f a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (f a -> f a -> f a
forall a. Semigroup a => a -> a -> a
(<>) (f a -> f a -> f a) -> (a -> f a) -> a -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall a. Dom f a => a -> f a
forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure) f a
forall a. Monoid a => a
mempty
  {-# INLINE cbasicFromList #-}

  ccons :: Dom f a => a -> f a -> f a
  {-# INLINE [1] ccons #-}
  ccons = f a -> f a -> f a
forall a. Semigroup a => a -> a -> a
(<>) (f a -> f a -> f a) -> (a -> f a) -> a -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall a. Dom f a => a -> f a
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 = ((f a -> f a) -> (a -> f a) -> a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall a. Dom f a => a -> f a
forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure) ((f a -> f a) -> a -> f a)
-> (f a -> f a -> f a) -> f a -> a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> f a -> f a
forall a. Semigroup a => a -> a -> a
(<>)

  {- |
    The 'cfromListN' function takes the input list's length as a hint. Its behaviour should be equivalent to 'cfromList'. The hint can be used to construct the structure l more efficiently compared to 'cfromList'.
    If the given hint does not equal to the input list's length the behaviour of fromListN is not specified.
  -}
  cfromListN :: Dom f a => Int -> [a] -> f a
  cfromListN = ([a] -> f a) -> Int -> [a] -> f a
forall a b. a -> b -> a
const [a] -> f a
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 = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
take Int
n ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
drop Int
n ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList

  cinit :: Dom f a => f a -> f a
  {-# INLINE [1] cinit #-}
  cinit = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. HasCallStack => [a] -> [a]
init ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList

  ctail :: Dom f a => f a -> f a
  ctail = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. HasCallStack => [a] -> [a]
tail ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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) -> ([a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList [a]
a, [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList [a]
b)) (([a], [a]) -> (f a, f a))
-> (f a -> ([a], [a])) -> f a -> (f a, f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [a] -> ([a], [a])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
n ([a] -> ([a], [a])) -> (f a -> [a]) -> f a -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (a -> [a]) -> a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> a -> [a]
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 ->
    [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList [Int -> a
f Int
i | Int
i <- [Int
0.. Int
n Int -> Int -> Int
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 ->
    [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> m [a] -> m (f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> m a) -> [Int] -> m [a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Int -> m a
f [Int
0..Int
nInt -> Int -> Int
forall 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 ->
    [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> g [a] -> g (f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> g a) -> [Int] -> g [a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse Int -> g a
f [Int
0..Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1]

  cuncons :: Dom f a => f a -> Maybe (a, f a)
  {-# INLINE [1] cuncons #-}
  cuncons = ((a, [a]) -> (a, f a)) -> Maybe (a, [a]) -> Maybe (a, f a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([a] -> f a) -> (a, [a]) -> (a, f a)
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) (Maybe (a, [a]) -> Maybe (a, f a))
-> (f a -> Maybe (a, [a])) -> f a -> Maybe (a, f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Maybe (a, [a])
forall a. [a] -> Maybe (a, [a])
uncons ([a] -> Maybe (a, [a])) -> (f a -> [a]) -> f a -> Maybe (a, [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 = (([a], a) -> (f a, a)) -> Maybe ([a], a) -> Maybe (f a, a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([a] -> f a) -> ([a], a) -> (f a, a)
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) (Maybe ([a], a) -> Maybe (f a, a))
-> (f a -> Maybe ([a], a)) -> f a -> Maybe (f a, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Maybe ([a], a)
[a] -> Maybe ([a], Element [a])
forall seq. IsSequence seq => seq -> Maybe (seq, Element seq)
MT.unsnoc ([a] -> Maybe ([a], a)) -> (f a -> [a]) -> f a -> Maybe ([a], a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList

  creverse :: Dom f a => f a -> f a
  {-# INLINE [1] creverse #-}
  creverse = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. [a] -> [a]
reverse ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList

  cintersperse :: Dom f a => a -> f a -> f a
  cintersperse = \a
a -> [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a] -> [a]
forall a. a -> [a] -> [a]
intersperse a
a ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. Eq a => [a] -> [a]
nub ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handler (f a) a -> Fold a [a] -> f a -> [a]
forall s a b. Handler s a -> Fold a b -> s -> b
L.foldOver (a -> Const (Dual (Endo x)) a)
-> f a -> Const (Dual (Endo x)) (f a)
Handler (f a) a
forall (f :: * -> *).
(Contravariant f, Applicative f) =>
(a -> f a) -> f a -> f (f a)
forall (t :: * -> *) a (f :: * -> *).
(CFoldable t, Dom t a, Contravariant f, Applicative f) =>
(a -> f a) -> t a -> f (t a)
cfolded Fold a [a]
forall a. Ord a => Fold a [a]
L.nub

  csort :: (Dom f a, Ord a) => f a -> f a
  {-# INLINE [1] csort #-}
  csort = [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. Ord a => [a] -> [a]
List.sort ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Ordering) -> [a] -> [a]
forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy a -> a -> Ordering
f ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a] -> [a]
forall a. Ord a => a -> [a] -> [a]
List.insert a
a ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Ordering) -> a -> [a] -> [a]
forall a. (a -> a -> Ordering) -> a -> [a] -> [a]
List.insertBy a -> a -> Ordering
f a
a ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile a -> Bool
f ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile a -> Bool
f ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> ([a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> ([a] -> f a) -> ([a], [a]) -> (f a, f a)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) (([a], [a]) -> (f a, f a))
-> (f a -> ([a], [a])) -> f a -> (f a, f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span a -> Bool
f ([a] -> ([a], [a])) -> (f a -> [a]) -> f a -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> ([a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> ([a] -> f a) -> ([a], [a]) -> (f a, f a)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) (([a], [a]) -> (f a, f a))
-> (f a -> ([a], [a])) -> f a -> (f a, f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break a -> Bool
f ([a] -> ([a], [a])) -> (f a -> [a]) -> f a -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> (f a -> [a]) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter a -> Bool
f ([a] -> [a]) -> (f a -> [a]) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
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 -> ([a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList ([a] -> f a) -> ([a] -> f a) -> ([a], [a]) -> (f a, f a)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** [a] -> f a
forall (f :: * -> *) a. (CFreeMonoid f, Dom f a) => [a] -> f a
cfromList) (([a], [a]) -> (f a, f a))
-> (f a -> ([a], [a])) -> f a -> (f a, f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
List.partition a -> Bool
f ([a] -> ([a], [a])) -> (f a -> [a]) -> f a -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [a]
forall (f :: * -> *) a. (CFoldable f, Dom f a) => f a -> [a]
ctoList

  -- TODO: more ListLike equivalent functions here

instance CFreeMonoid [] where
  cbasicFromList :: forall a. Dom [] a => [a] -> [a]
cbasicFromList = [a] -> [a]
forall a. a -> a
id
  {-# INLINE cbasicFromList #-}
  cfromListN :: forall a. Dom [] a => Int -> [a] -> [a]
cfromListN = Int -> [a] -> [a]
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 [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a
x]
  {-# INLINE [1] csnoc #-}
  ctake :: forall a. Dom [] a => Int -> [a] -> [a]
ctake = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
take
  {-# INLINE [1] ctake #-}
  cdrop :: forall a. Dom [] a => Int -> [a] -> [a]
cdrop = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
drop
  {-# INLINE [1] cdrop #-}
  cinit :: forall a. Dom [] a => [a] -> [a]
cinit = [a] -> [a]
forall a. HasCallStack => [a] -> [a]
init
  {-# INLINE [1] cinit #-}
  ctail :: forall a. Dom [] a => [a] -> [a]
ctail = [a] -> [a]
forall a. HasCallStack => [a] -> [a]
tail
  {-# INLINE [1] ctail #-}
  csplitAt :: forall a. Dom [] a => Int -> [a] -> ([a], [a])
csplitAt = Int -> [a] -> ([a], [a])
forall a. Int -> [a] -> ([a], [a])
splitAt
  {-# INLINE [1] csplitAt #-}
  creplicate :: forall a. Dom [] a => Int -> a -> [a]
creplicate = Int -> a -> [a]
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 -> (Int -> m a) -> [Int] -> m [a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Int -> m a
f [Int
0..Int
nInt -> Int -> Int
forall 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 -> (Int -> g a) -> [Int] -> g [a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse Int -> g a
f [Int
0..Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1]
  {-# INLINE [1] cgenerateA #-}
  cuncons :: forall a. Dom [] a => [a] -> Maybe (a, [a])
cuncons = [a] -> Maybe (a, [a])
forall a. [a] -> Maybe (a, [a])
uncons
  {-# INLINE [1] cuncons #-}
  cunsnoc :: forall a. Dom [] a => [a] -> Maybe ([a], a)
cunsnoc = [a] -> Maybe ([a], a)
[a] -> Maybe ([a], Element [a])
forall seq. IsSequence seq => seq -> Maybe (seq, Element seq)
MT.unsnoc
  {-# INLINE [1] cunsnoc #-}
  creverse :: forall a. Dom [] a => [a] -> [a]
creverse = [a] -> [a]
forall a. [a] -> [a]
reverse
  {-# INLINE [1] creverse #-}
  cintersperse :: forall a. Dom [] a => a -> [a] -> [a]
cintersperse = a -> [a] -> [a]
forall a. a -> [a] -> [a]
intersperse
  {-# INLINE [1] cintersperse #-}
  cnub :: forall a. (Dom [] a, Eq a) => [a] -> [a]
cnub = [a] -> [a]
forall a. (Dom [] a, Eq a) => [a] -> [a]
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 = [a] -> [a]
forall a. Ord a => [a] -> [a]
List.sort
  {-# INLINE [1] csort #-}
  csortBy :: forall a. Dom [] a => (a -> a -> Ordering) -> [a] -> [a]
csortBy = (a -> a -> Ordering) -> [a] -> [a]
forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy
  {-# INLINE [1] csortBy #-}
  ctakeWhile :: forall a. Dom [] a => (a -> Bool) -> [a] -> [a]
ctakeWhile = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile
  {-# INLINE [1] ctakeWhile #-}
  cdropWhile :: forall a. Dom [] a => (a -> Bool) -> [a] -> [a]
cdropWhile = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile
  {-# INLINE [1] cdropWhile #-}
  cspan :: forall a. Dom [] a => (a -> Bool) -> [a] -> ([a], [a])
cspan = (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span
  {-# INLINE [1] cspan #-}
  cbreak :: forall a. Dom [] a => (a -> Bool) -> [a] -> ([a], [a])
cbreak = (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break
  {-# INLINE [1] cbreak #-}
  cfilter :: forall a. Dom [] a => (a -> Bool) -> [a] -> [a]
cfilter = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter
  {-# INLINE [1] cfilter #-}
  cpartition :: forall a. Dom [] a => (a -> Bool) -> [a] -> ([a], [a])
cpartition = (a -> Bool) -> [a] -> ([a], [a])
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 = [a] -> PrimArray a
forall a. Prim a => [a] -> PrimArray a
PA.primArrayFromList
  {-# INLINE cbasicFromList #-}
  cfromListN :: forall a. Dom PrimArray a => Int -> [a] -> PrimArray a
cfromListN = Int -> [a] -> PrimArray a
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 = Int -> (Int -> a) -> PrimArray a
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 = Int -> (Int -> m a) -> m (PrimArray a)
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 = Int -> (Int -> g a) -> g (PrimArray a)
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 = (a -> Bool) -> PrimArray a -> PrimArray a
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 = Int -> a -> PrimArray a
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 = [a] -> SmallArray a
forall a. [a] -> SmallArray a
SA.smallArrayFromList
  {-# INLINE cbasicFromList #-}
  cfromListN :: forall a. Dom SmallArray a => Int -> [a] -> SmallArray a
cfromListN = Int -> [a] -> SmallArray a
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 = [a] -> Array a
forall a. [a] -> Array a
A.arrayFromList
  {-# INLINE cbasicFromList #-}
  cfromListN :: forall a. Dom Array a => Int -> [a] -> Array a
cfromListN = Int -> [a] -> Array a
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 = [a] -> Seq a
forall a. [a] -> Seq a
Seq.fromList
  {-# INLINE cbasicFromList #-}
  cfromListN :: forall a. Dom Seq a => Int -> [a] -> Seq a
cfromListN = Int -> [a] -> Seq a
Int -> [Item (Seq a)] -> Seq a
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 = ([Element mono] -> mono) -> [a] -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce (([Element mono] -> mono) -> [a] -> WrapMono mono a)
-> ([Element mono] -> mono) -> [a] -> WrapMono mono a
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 -> ([a] -> mono) -> [a] -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce (([a] -> mono) -> [a] -> WrapMono mono a)
-> ([a] -> mono) -> [a] -> WrapMono mono a
forall a b. (a -> b) -> a -> b
$ Index mono -> mono -> mono
forall seq. IsSequence seq => Index seq -> seq -> seq
MT.take (Int -> Index mono
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n) (mono -> mono) -> ([a] -> mono) -> [a] -> mono
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 = (mono -> mono) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((mono -> mono) -> WrapMono mono a -> WrapMono mono a)
-> (Int -> mono -> mono)
-> Int
-> WrapMono mono a
-> WrapMono mono a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall seq. IsSequence seq => Index seq -> seq -> seq
MT.take @mono (Index mono -> mono -> mono)
-> (Int -> Index mono) -> Int -> mono -> mono
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Index mono
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 = (mono -> mono) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((mono -> mono) -> WrapMono mono a -> WrapMono mono a)
-> (Int -> mono -> mono)
-> Int
-> WrapMono mono a
-> WrapMono mono a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall seq. IsSequence seq => Index seq -> seq -> seq
MT.drop @mono (Index mono -> mono -> mono)
-> (Int -> Index mono) -> Int -> mono -> mono
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Index mono
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 = (Element mono -> mono -> mono)
-> a -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((Element mono -> mono -> mono)
 -> a -> WrapMono mono a -> WrapMono mono a)
-> (Element mono -> mono -> mono)
-> a
-> WrapMono mono a
-> WrapMono mono a
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 = (mono -> Element mono -> mono)
-> WrapMono mono a -> a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((mono -> Element mono -> mono)
 -> WrapMono mono a -> a -> WrapMono mono a)
-> (mono -> Element mono -> mono)
-> WrapMono mono a
-> a
-> WrapMono mono a
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 = (mono -> Maybe (Element mono, mono))
-> WrapMono mono a -> Maybe (a, WrapMono mono a)
forall a b. Coercible a b => a -> b
coerce ((mono -> Maybe (Element mono, mono))
 -> WrapMono mono a -> Maybe (a, WrapMono mono a))
-> (mono -> Maybe (Element mono, mono))
-> WrapMono mono a
-> Maybe (a, WrapMono mono a)
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 = (mono -> Maybe (mono, Element mono))
-> WrapMono mono a -> Maybe (WrapMono mono a, a)
forall a b. Coercible a b => a -> b
coerce ((mono -> Maybe (mono, Element mono))
 -> WrapMono mono a -> Maybe (WrapMono mono a, a))
-> (mono -> Maybe (mono, Element mono))
-> WrapMono mono a
-> Maybe (WrapMono mono a, a)
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 = (mono -> mono) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((mono -> mono) -> WrapMono mono a -> WrapMono mono a)
-> (mono -> mono) -> WrapMono mono a -> WrapMono mono a
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 = (mono -> mono) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((mono -> mono) -> WrapMono mono a -> WrapMono mono a)
-> (mono -> mono) -> WrapMono mono a -> WrapMono mono a
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 = (Int -> mono -> (mono, mono))
-> Int -> WrapMono mono a -> (WrapMono mono a, WrapMono mono a)
forall a b. Coercible a b => a -> b
coerce ((Int -> mono -> (mono, mono))
 -> Int -> WrapMono mono a -> (WrapMono mono a, WrapMono mono a))
-> (Int -> mono -> (mono, mono))
-> Int
-> WrapMono mono a
-> (WrapMono mono a, WrapMono mono a)
forall a b. (a -> b) -> a -> b
$ \(Int
n :: Int) ->
      forall seq. IsSequence seq => Index seq -> seq -> (seq, seq)
MT.splitAt @mono (Int -> Index 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 = (Int -> a -> mono) -> Int -> a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((Int -> a -> mono) -> Int -> a -> WrapMono mono a)
-> (Int -> a -> mono) -> Int -> a -> WrapMono mono a
forall a b. (a -> b) -> a -> b
$ \(Int
n :: Int) ->
      forall seq. IsSequence seq => Index seq -> Element seq -> seq
MT.replicate @mono (Int -> Index 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 = (mono -> mono) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((mono -> mono) -> WrapMono mono a -> WrapMono mono a)
-> (mono -> mono) -> WrapMono mono a -> WrapMono mono a
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 = (Element mono -> mono -> mono)
-> a -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((Element mono -> mono -> mono)
 -> a -> WrapMono mono a -> WrapMono mono a)
-> (Element mono -> mono -> mono)
-> a
-> WrapMono mono a
-> WrapMono mono a
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 = (mono -> mono) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce ((mono -> mono) -> WrapMono mono a -> WrapMono mono a)
-> (mono -> mono) -> WrapMono mono a -> WrapMono mono a
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 = ((Element mono -> Element mono -> Ordering) -> mono -> mono)
-> (a -> a -> Ordering) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce (((Element mono -> Element mono -> Ordering) -> mono -> mono)
 -> (a -> a -> Ordering) -> WrapMono mono a -> WrapMono mono a)
-> ((Element mono -> Element mono -> Ordering) -> mono -> mono)
-> (a -> a -> Ordering)
-> WrapMono mono a
-> WrapMono mono a
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 = ((Element mono -> Bool) -> mono -> mono)
-> (a -> Bool) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce (((Element mono -> Bool) -> mono -> mono)
 -> (a -> Bool) -> WrapMono mono a -> WrapMono mono a)
-> ((Element mono -> Bool) -> mono -> mono)
-> (a -> Bool)
-> WrapMono mono a
-> WrapMono mono a
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 = ((Element mono -> Bool) -> mono -> mono)
-> (a -> Bool) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce (((Element mono -> Bool) -> mono -> mono)
 -> (a -> Bool) -> WrapMono mono a -> WrapMono mono a)
-> ((Element mono -> Bool) -> mono -> mono)
-> (a -> Bool)
-> WrapMono mono a
-> WrapMono mono a
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 = ((Element mono -> Bool) -> mono -> (mono, mono))
-> (a -> Bool)
-> WrapMono mono a
-> (WrapMono mono a, WrapMono mono a)
forall a b. Coercible a b => a -> b
coerce (((Element mono -> Bool) -> mono -> (mono, mono))
 -> (a -> Bool)
 -> WrapMono mono a
 -> (WrapMono mono a, WrapMono mono a))
-> ((Element mono -> Bool) -> mono -> (mono, mono))
-> (a -> Bool)
-> WrapMono mono a
-> (WrapMono mono a, WrapMono mono a)
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 = ((Element mono -> Bool) -> mono -> (mono, mono))
-> (a -> Bool)
-> WrapMono mono a
-> (WrapMono mono a, WrapMono mono a)
forall a b. Coercible a b => a -> b
coerce (((Element mono -> Bool) -> mono -> (mono, mono))
 -> (a -> Bool)
 -> WrapMono mono a
 -> (WrapMono mono a, WrapMono mono a))
-> ((Element mono -> Bool) -> mono -> (mono, mono))
-> (a -> Bool)
-> WrapMono mono a
-> (WrapMono mono a, WrapMono mono a)
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 = ((Element mono -> Bool) -> mono -> mono)
-> (a -> Bool) -> WrapMono mono a -> WrapMono mono a
forall a b. Coercible a b => a -> b
coerce (((Element mono -> Bool) -> mono -> mono)
 -> (a -> Bool) -> WrapMono mono a -> WrapMono mono a)
-> ((Element mono -> Bool) -> mono -> mono)
-> (a -> Bool)
-> WrapMono mono a
-> WrapMono mono a
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 = ((Element mono -> Bool) -> mono -> (mono, mono))
-> (a -> Bool)
-> WrapMono mono a
-> (WrapMono mono a, WrapMono mono a)
forall a b. Coercible a b => a -> b
coerce (((Element mono -> Bool) -> mono -> (mono, mono))
 -> (a -> Bool)
 -> WrapMono mono a
 -> (WrapMono mono a, WrapMono mono a))
-> ((Element mono -> Bool) -> mono -> (mono, mono))
-> (a -> Bool)
-> WrapMono mono a
-> (WrapMono mono a, WrapMono mono a)
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 =
  CApp f (t b) -> f (t b)
forall {k} (f :: k -> *) (a :: k). CApp f a -> f a
runCApp (CApp f (t b) -> f (t b))
-> (t a -> CApp f (t b)) -> t a -> f (t b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> CApp f (t b)) -> t a -> CApp f (t b)
forall a w. (Dom t a, Monoid w) => (a -> w) -> t a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (f (t b) -> CApp f (t b)
forall {k} (f :: k -> *) (a :: k). f a -> CApp f a
CApp (f (t b) -> CApp f (t b)) -> (a -> f (t b)) -> a -> CApp f (t b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> t b) -> f b -> f (t b)
forall a b. (Dom f a, Dom f b) => (a -> b) -> f a -> f b
forall (f :: * -> *) a b.
(CFunctor f, Dom f a, Dom f b) =>
(a -> b) -> f a -> f b
cmap b -> t b
forall a. Dom t a => a -> t a
forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure (f b -> f (t b)) -> (a -> f b) -> a -> f (t b)
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 =
  CZippy f (t b) -> f (t b)
forall {k} (f :: k -> *) (a :: k). CZippy f a -> f a
runCZippy (CZippy f (t b) -> f (t b))
-> (t a -> CZippy f (t b)) -> t a -> f (t b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> CZippy f (t b)) -> t a -> CZippy f (t b)
forall a w. (Dom t a, Monoid w) => (a -> w) -> t a -> w
forall (f :: * -> *) a w.
(CFoldable f, Dom f a, Monoid w) =>
(a -> w) -> f a -> w
cfoldMap (f (t b) -> CZippy f (t b)
forall {k} (f :: k -> *) (a :: k). f a -> CZippy f a
CZippy (f (t b) -> CZippy f (t b))
-> (a -> f (t b)) -> a -> CZippy f (t b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> t b) -> f b -> f (t b)
forall a b. (Dom f a, Dom f b) => (a -> b) -> f a -> f b
forall (f :: * -> *) a b.
(CFunctor f, Dom f a, Dom f b) =>
(a -> b) -> f a -> f b
cmap b -> t b
forall a. Dom t a => a -> t a
forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure (f b -> f (t b)) -> (a -> f b) -> a -> f (t b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f b
f)

-- | Lifts 'CFoldable' along given function.
--
--  @
--    cfolding :: (CFoldable t, Dom t a) => (s -> t a) -> Fold s a
--  @
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 -> f () -> f s
forall (f :: * -> *) a b.
(Functor f, Contravariant f) =>
f a -> f b
phantom (f () -> f s) -> (s -> f ()) -> s -> f s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> t a -> f ()
forall (f :: * -> *) (g :: * -> *) a b.
(CFoldable f, Applicative g, Dom f a) =>
(a -> g b) -> f a -> g ()
forall (g :: * -> *) a b.
(Applicative g, Dom t a) =>
(a -> g b) -> t a -> g ()
ctraverse_ a -> f a
agb (t a -> f ()) -> (s -> t a) -> s -> f ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> t a
sfa