-- | Generic implementation of 'Foldable' and 'Traversable'.
--
-- There is already a naive implementation using the generic @'Rep'@'s
-- own instances of 'Foldable' and 'Traversable'. However, deriving then
-- generates a lot of code that may not be simplified away by GHC,
-- that results in unnecessary run-time overhead.
--
-- In contrast, this implementation guarantees that the generated code is
-- identical to stock-derived instances of 'Foldable' and 'Traversable',
-- which have the following syntactic properties:
--
-- - constructors with zero fields use 'pure' once;
-- - constructors with one field use 'fmap' once;
-- - constructors with n >= 2 fields use 'liftA2' once and @('<*>')@ n-2 times.
--
-- The heavy lifting is actually done by the ap-normalize library.

{-# LANGUAGE
  DataKinds,
  EmptyCase,
  FlexibleContexts,
  FlexibleInstances,
  GADTs,
  KindSignatures,
  MultiParamTypeClasses,
  ScopedTypeVariables,
  TypeApplications,
  TypeOperators,
  UndecidableInstances,
  UndecidableSuperClasses #-}

module Generic.Data.Internal.Traversable where

import Control.Applicative (liftA2)
import Data.Kind (Type)
import Data.Monoid
import GHC.Generics

import ApNormalize

-- * Library

-- | Generic 'foldMap'.
--
-- @
-- instance 'Foldable' MyTypeF where
--   'foldMap' = 'gfoldMap'
-- @
gfoldMap :: (Generic1 f, GFoldable (Rep1 f), Monoid m) => (a -> m) -> f a -> m
gfoldMap :: forall (f :: * -> *) m a.
(Generic1 f, GFoldable (Rep1 f), Monoid m) =>
(a -> m) -> f a -> m
gfoldMap = \a -> m
f -> EndoM m -> m
forall m. Monoid m => EndoM m -> m
lowerEndoM (EndoM m -> m) -> (f a -> EndoM m) -> f a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> m) -> Rep1 f a -> EndoM m
forall m a. Monoid m => (a -> m) -> Rep1 f a -> EndoM m
forall (t :: * -> *) m a.
(GFoldMap t, Monoid m) =>
(a -> m) -> t a -> EndoM m
gfoldMap_ a -> m
f (Rep1 f a -> EndoM m) -> (f a -> Rep1 f a) -> f a -> EndoM m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> Rep1 f a
forall a. f a -> Rep1 f a
forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
from1
{-# INLINE gfoldMap #-}

-- | Generic 'traverse'.
--
-- @
-- instance 'Traversable' MyTypeF where
--   'traverse' = 'gtraverse'
-- @
gtraverse
  :: (Generic1 f, GTraversable (Rep1 f), Applicative m)
  => (a -> m b) -> f a -> m (f b)
gtraverse :: forall (f :: * -> *) (m :: * -> *) a b.
(Generic1 f, GTraversable (Rep1 f), Applicative m) =>
(a -> m b) -> f a -> m (f b)
gtraverse = \a -> m b
f -> Aps m (f b) -> m (f b)
forall (f :: * -> *) a. Applicative f => Aps f a -> f a
lowerAps (Aps m (f b) -> m (f b)) -> (f a -> Aps m (f b)) -> f a -> m (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rep1 f b -> f b) -> Aps m (Rep1 f b) -> Aps m (f b)
forall a b. (a -> b) -> Aps m a -> Aps m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep1 f b -> f b
forall a. Rep1 f a -> f a
forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
to1 (Aps m (Rep1 f b) -> Aps m (f b))
-> (f a -> Aps m (Rep1 f b)) -> f a -> Aps m (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Kleisli m a b -> Rep1 f a -> Aps m (Rep1 f b)
forall (f :: * -> *) a b.
Applicative f =>
Kleisli f a b -> Rep1 f a -> Aps f (Rep1 f b)
forall (arr :: (* -> *) -> * -> * -> *) (t :: * -> *) (f :: * -> *)
       a b.
(GTraverse arr t, Applicative f) =>
arr f a b -> t a -> Aps f (t b)
gtraverse_ ((a -> m b) -> Kleisli m a b
forall (f :: * -> *) a b. (a -> f b) -> Kleisli f a b
Kleisli a -> m b
f) (Rep1 f a -> Aps m (Rep1 f b))
-> (f a -> Rep1 f a) -> f a -> Aps m (Rep1 f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> Rep1 f a
forall a. f a -> Rep1 f a
forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
from1
{-# INLINE gtraverse #-}

-- | Generic 'sequenceA'.
--
-- @
-- instance 'Traversable' MyTypeF where
--   'sequenceA' = 'gsequenceA'
-- @
--
-- See also 'gtraverse'.
--
gsequenceA
  :: (Generic1 f, GTraversable (Rep1 f), Applicative m)
  => f (m a) -> m (f a)
gsequenceA :: forall (f :: * -> *) (m :: * -> *) a.
(Generic1 f, GTraversable (Rep1 f), Applicative m) =>
f (m a) -> m (f a)
gsequenceA = Aps m (f a) -> m (f a)
forall (f :: * -> *) a. Applicative f => Aps f a -> f a
lowerAps (Aps m (f a) -> m (f a))
-> (f (m a) -> Aps m (f a)) -> f (m a) -> m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rep1 f a -> f a) -> Aps m (Rep1 f a) -> Aps m (f a)
forall a b. (a -> b) -> Aps m a -> Aps m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep1 f a -> f a
forall a. Rep1 f a -> f a
forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
to1 (Aps m (Rep1 f a) -> Aps m (f a))
-> (f (m a) -> Aps m (Rep1 f a)) -> f (m a) -> Aps m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Equal m (m a) a -> Rep1 f (m a) -> Aps m (Rep1 f a)
forall (f :: * -> *) a b.
Applicative f =>
Equal f a b -> Rep1 f a -> Aps f (Rep1 f b)
forall (arr :: (* -> *) -> * -> * -> *) (t :: * -> *) (f :: * -> *)
       a b.
(GTraverse arr t, Applicative f) =>
arr f a b -> t a -> Aps f (t b)
gtraverse_ Equal m (m a) a
forall (f :: * -> *) b. Equal f (f b) b
Refl (Rep1 f (m a) -> Aps m (Rep1 f a))
-> (f (m a) -> Rep1 f (m a)) -> f (m a) -> Aps m (Rep1 f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f (m a) -> Rep1 f (m a)
forall a. f a -> Rep1 f a
forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
from1
{-# INLINE gsequenceA #-}

-- | Class of generic representations for which 'Foldable' can be derived.
class    GFoldable_ t => GFoldable t
instance GFoldable_ t => GFoldable t

-- | Class of generic representations for which 'Traversable' can be derived.
class    GTraversable_ t => GTraversable t
instance GTraversable_ t => GTraversable t

-- | Internal definition of 'GFoldable'.
class    (GFoldMap t, Foldable t) => GFoldable_ t
instance (GFoldMap t, Foldable t) => GFoldable_ t

-- | Internal definition of 'GTraversable'.
class    (GTraverse Kleisli t, GTraverse Equal t) => GTraversable_ t
instance (GTraverse Kleisli t, GTraverse Equal t) => GTraversable_ t

-- Implementation

-- ** Foldable

-- | Isomorphic to @Maybe m@, but we need to micromanage the
-- use of Monoid vs Semigroup to match exactly the output
-- of stock deriving, for inspection testing.
data Maybe' m = Nothing' | Just' m

type EndoM m = Endo (Maybe' m)

liftEndoM :: Monoid m => m -> EndoM m
liftEndoM :: forall m. Monoid m => m -> EndoM m
liftEndoM m
x = (Maybe' m -> Maybe' m) -> Endo (Maybe' m)
forall a. (a -> a) -> Endo a
Endo Maybe' m -> Maybe' m
app where
  app :: Maybe' m -> Maybe' m
app Maybe' m
Nothing' = m -> Maybe' m
forall m. m -> Maybe' m
Just' m
x
  app (Just' m
y) = m -> Maybe' m
forall m. m -> Maybe' m
Just' (m
x m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` m
y)
{-# INLINE liftEndoM #-}

lowerEndoM :: Monoid m => EndoM m -> m
lowerEndoM :: forall m. Monoid m => EndoM m -> m
lowerEndoM (Endo Maybe' m -> Maybe' m
app) = Maybe' m -> m
forall m. Monoid m => Maybe' m -> m
lowerMaybe (Maybe' m -> Maybe' m
app Maybe' m
forall m. Maybe' m
Nothing')
{-# INLINE lowerEndoM #-}

lowerMaybe :: Monoid m => Maybe' m -> m
lowerMaybe :: forall m. Monoid m => Maybe' m -> m
lowerMaybe Maybe' m
Nothing' = m
forall a. Monoid a => a
mempty
lowerMaybe (Just' m
x) = m
x
{-# INLINE lowerMaybe #-}

class GFoldMap t where
  gfoldMap_ :: Monoid m => (a -> m) -> t a -> EndoM m

instance GFoldMap f => GFoldMap (M1 i c f) where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> M1 i c f a -> EndoM m
gfoldMap_ a -> m
f (M1 f a
x) = (a -> m) -> f a -> EndoM m
forall m a. Monoid m => (a -> m) -> f a -> EndoM m
forall (t :: * -> *) m a.
(GFoldMap t, Monoid m) =>
(a -> m) -> t a -> EndoM m
gfoldMap_ a -> m
f f a
x
  {-# INLINE gfoldMap_ #-}

instance (GFoldMap f, GFoldMap g) => GFoldMap (f :+: g) where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> (:+:) f g a -> EndoM m
gfoldMap_ a -> m
f (L1 f a
x) = (a -> m) -> f a -> EndoM m
forall m a. Monoid m => (a -> m) -> f a -> EndoM m
forall (t :: * -> *) m a.
(GFoldMap t, Monoid m) =>
(a -> m) -> t a -> EndoM m
gfoldMap_ a -> m
f f a
x
  gfoldMap_ a -> m
f (R1 g a
y) = (a -> m) -> g a -> EndoM m
forall m a. Monoid m => (a -> m) -> g a -> EndoM m
forall (t :: * -> *) m a.
(GFoldMap t, Monoid m) =>
(a -> m) -> t a -> EndoM m
gfoldMap_ a -> m
f g a
y
  {-# INLINE gfoldMap_ #-}

instance (GFoldMap f, GFoldMap g) => GFoldMap (f :*: g) where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> (:*:) f g a -> EndoM m
gfoldMap_ a -> m
f (f a
x :*: g a
y) = (a -> m) -> f a -> EndoM m
forall m a. Monoid m => (a -> m) -> f a -> EndoM m
forall (t :: * -> *) m a.
(GFoldMap t, Monoid m) =>
(a -> m) -> t a -> EndoM m
gfoldMap_ a -> m
f f a
x EndoM m -> EndoM m -> EndoM m
forall a. Monoid a => a -> a -> a
`mappend` (a -> m) -> g a -> EndoM m
forall m a. Monoid m => (a -> m) -> g a -> EndoM m
forall (t :: * -> *) m a.
(GFoldMap t, Monoid m) =>
(a -> m) -> t a -> EndoM m
gfoldMap_ a -> m
f g a
y
  {-# INLINE gfoldMap_ #-}

instance GFoldMap U1 where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> U1 a -> EndoM m
gfoldMap_ a -> m
_ U1 a
_ = EndoM m
forall a. Monoid a => a
mempty
  {-# INLINE gfoldMap_ #-}

instance GFoldMap V1 where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> V1 a -> EndoM m
gfoldMap_ a -> m
_ V1 a
v = case V1 a
v of {}
  {-# INLINE gfoldMap_ #-}

instance GFoldMap (K1 i a) where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> K1 i a a -> EndoM m
gfoldMap_ a -> m
_ (K1 a
_) = EndoM m
forall a. Monoid a => a
mempty
  {-# INLINE gfoldMap_ #-}

instance GFoldMap Par1 where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> Par1 a -> EndoM m
gfoldMap_ a -> m
f (Par1 a
x) = m -> EndoM m
forall m. Monoid m => m -> EndoM m
liftEndoM (a -> m
f a
x)
  {-# INLINE gfoldMap_ #-}

instance Foldable t => GFoldMap (Rec1 t) where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> Rec1 t a -> EndoM m
gfoldMap_ a -> m
f (Rec1 t a
x) = m -> EndoM m
forall m. Monoid m => m -> EndoM m
liftEndoM ((a -> m) -> t a -> m
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f t a
x)
  {-# INLINE gfoldMap_ #-}

instance (Foldable t, Foldable f) => GFoldMap (t :.: f) where
  gfoldMap_ :: forall m a. Monoid m => (a -> m) -> (:.:) t f a -> EndoM m
gfoldMap_ a -> m
f (Comp1 t (f a)
x) = m -> EndoM m
forall m. Monoid m => m -> EndoM m
liftEndoM ((f a -> m) -> t (f a) -> m
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((a -> m) -> f a -> m
forall m a. Monoid m => (a -> m) -> f a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f) t (f a)
x)
  {-# INLINE gfoldMap_ #-}


-- ** Traversable

data Equal (f :: Type -> Type) a b where
  Refl :: Equal f (f b) b

newtype Kleisli f a b = Kleisli (a -> f b)

class GTraverse arr t where
  gtraverse_ :: Applicative f => arr f a b -> t a -> Aps f (t b)

instance GTraverse arr f => GTraverse arr (M1 i c f) where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> M1 i c f a -> Aps f (M1 i c f b)
gtraverse_ arr f a b
f (M1 f a
x) = f b -> M1 i c f b
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (f b -> M1 i c f b) -> Aps f (f b) -> Aps f (M1 i c f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> arr f a b -> f a -> Aps f (f b)
forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> f a -> Aps f (f b)
forall (arr :: (* -> *) -> * -> * -> *) (t :: * -> *) (f :: * -> *)
       a b.
(GTraverse arr t, Applicative f) =>
arr f a b -> t a -> Aps f (t b)
gtraverse_ arr f a b
f f a
x
  {-# INLINE gtraverse_ #-}

instance (GTraverse arr f, GTraverse arr g) => GTraverse arr (f :+: g) where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> (:+:) f g a -> Aps f ((:+:) f g b)
gtraverse_ arr f a b
f (L1 f a
x) = f b -> (:+:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (f b -> (:+:) f g b) -> Aps f (f b) -> Aps f ((:+:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> arr f a b -> f a -> Aps f (f b)
forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> f a -> Aps f (f b)
forall (arr :: (* -> *) -> * -> * -> *) (t :: * -> *) (f :: * -> *)
       a b.
(GTraverse arr t, Applicative f) =>
arr f a b -> t a -> Aps f (t b)
gtraverse_ arr f a b
f f a
x
  gtraverse_ arr f a b
f (R1 g a
y) = g b -> (:+:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (g b -> (:+:) f g b) -> Aps f (g b) -> Aps f ((:+:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> arr f a b -> g a -> Aps f (g b)
forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> g a -> Aps f (g b)
forall (arr :: (* -> *) -> * -> * -> *) (t :: * -> *) (f :: * -> *)
       a b.
(GTraverse arr t, Applicative f) =>
arr f a b -> t a -> Aps f (t b)
gtraverse_ arr f a b
f g a
y
  {-# INLINE gtraverse_ #-}

instance (GTraverse arr f, GTraverse arr g) => GTraverse arr (f :*: g) where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> (:*:) f g a -> Aps f ((:*:) f g b)
gtraverse_ arr f a b
f (f a
x :*: g a
y) = (f b -> g b -> (:*:) f g b)
-> Aps f (f b) -> Aps f (g b) -> Aps f ((:*:) f g b)
forall a b c. (a -> b -> c) -> Aps f a -> Aps f b -> Aps f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 f b -> g b -> (:*:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (arr f a b -> f a -> Aps f (f b)
forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> f a -> Aps f (f b)
forall (arr :: (* -> *) -> * -> * -> *) (t :: * -> *) (f :: * -> *)
       a b.
(GTraverse arr t, Applicative f) =>
arr f a b -> t a -> Aps f (t b)
gtraverse_ arr f a b
f f a
x) (arr f a b -> g a -> Aps f (g b)
forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> g a -> Aps f (g b)
forall (arr :: (* -> *) -> * -> * -> *) (t :: * -> *) (f :: * -> *)
       a b.
(GTraverse arr t, Applicative f) =>
arr f a b -> t a -> Aps f (t b)
gtraverse_ arr f a b
f g a
y)
  {-# INLINE gtraverse_ #-}

instance GTraverse arr U1 where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> U1 a -> Aps f (U1 b)
gtraverse_ arr f a b
_ U1 a
_ = U1 b -> Aps f (U1 b)
forall a. a -> Aps f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 b
forall k (p :: k). U1 p
U1
  {-# INLINE gtraverse_ #-}

instance GTraverse arr V1 where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> V1 a -> Aps f (V1 b)
gtraverse_ arr f a b
_ V1 a
v = case V1 a
v of {}
  {-# INLINE gtraverse_ #-}

instance GTraverse arr (K1 i a) where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
arr f a b -> K1 i a a -> Aps f (K1 i a b)
gtraverse_ arr f a b
_ (K1 a
x) = K1 i a b -> Aps f (K1 i a b)
forall a. a -> Aps f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> K1 i a b
forall k i c (p :: k). c -> K1 i c p
K1 a
x)
  {-# INLINE gtraverse_ #-}

-- traverse

instance GTraverse Kleisli Par1 where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
Kleisli f a b -> Par1 a -> Aps f (Par1 b)
gtraverse_ (Kleisli a -> f b
f) (Par1 a
x) = b -> Par1 b
forall p. p -> Par1 p
Par1 (b -> Par1 b) -> Aps f b -> Aps f (Par1 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f b -> Aps f b
forall (f :: * -> *) a. f a -> Aps f a
liftAps (a -> f b
f a
x)
  {-# INLINE gtraverse_ #-}

instance Traversable t => GTraverse Kleisli (Rec1 t) where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
Kleisli f a b -> Rec1 t a -> Aps f (Rec1 t b)
gtraverse_ (Kleisli a -> f b
f) (Rec1 t a
x) = t b -> Rec1 t b
forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
Rec1 (t b -> Rec1 t b) -> Aps f (t b) -> Aps f (Rec1 t b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (t b) -> Aps f (t b)
forall (f :: * -> *) a. f a -> Aps f a
liftAps ((a -> f b) -> t a -> f (t 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) -> t a -> f (t b)
traverse a -> f b
f t a
x)
  {-# INLINE gtraverse_ #-}

-- Oh no, the encoding with @(':.:')@ is quite broken.
--
-- @t1 (... (tn (t a)) ...)@ is represented as:
-- @(t1 :.: (... :.: (tn :.: Rec1 t) ...)) a@
-- but it would be more efficient to associate to the left:
-- @(((... (Rec1 t1 :.: t2) :.: ...) :.: tn) :.: t) a
instance (Traversable t, Traversable f) => GTraverse Kleisli (t :.: f) where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
Kleisli f a b -> (:.:) t f a -> Aps f ((:.:) t f b)
gtraverse_ (Kleisli a -> f b
f) (Comp1 t (f a)
x) = t (f b) -> (:.:) t f b
forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 (t (f b) -> (:.:) t f b) -> Aps f (t (f b)) -> Aps f ((:.:) t f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (t (f b)) -> Aps f (t (f b))
forall (f :: * -> *) a. f a -> Aps f a
liftAps ((f a -> f (f b)) -> t (f a) -> f (t (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) -> t a -> f (t b)
traverse ((a -> f b) -> f a -> f (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) -> f a -> f (f b)
traverse a -> f b
f) t (f a)
x)
  {-# INLINE gtraverse_ #-}

-- sequenceA

instance GTraverse Equal Par1 where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
Equal f a b -> Par1 a -> Aps f (Par1 b)
gtraverse_ Equal f a b
Refl (Par1 a
x) = b -> Par1 b
forall p. p -> Par1 p
Par1 (b -> Par1 b) -> Aps f b -> Aps f (Par1 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f b -> Aps f b
forall (f :: * -> *) a. f a -> Aps f a
liftAps a
f b
x
  {-# INLINE gtraverse_ #-}

instance Traversable t => GTraverse Equal (Rec1 t) where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
Equal f a b -> Rec1 t a -> Aps f (Rec1 t b)
gtraverse_ Equal f a b
Refl (Rec1 t a
x) = t b -> Rec1 t b
forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
Rec1 (t b -> Rec1 t b) -> Aps f (t b) -> Aps f (Rec1 t b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (t b) -> Aps f (t b)
forall (f :: * -> *) a. f a -> Aps f a
liftAps (t (f b) -> f (t b)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a)
sequenceA t a
t (f b)
x)
  {-# INLINE gtraverse_ #-}

instance (Traversable t, Traversable f) => GTraverse Equal (t :.: f) where
  gtraverse_ :: forall (f :: * -> *) a b.
Applicative f =>
Equal f a b -> (:.:) t f a -> Aps f ((:.:) t f b)
gtraverse_ Equal f a b
Refl (Comp1 t (f a)
x) = t (f b) -> (:.:) t f b
forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 (t (f b) -> (:.:) t f b) -> Aps f (t (f b)) -> Aps f ((:.:) t f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (t (f b)) -> Aps f (t (f b))
forall (f :: * -> *) a. f a -> Aps f a
liftAps ((f (f b) -> f (f b)) -> t (f (f b)) -> f (t (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) -> t a -> f (t b)
traverse f (f b) -> f (f b)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => f (f a) -> f (f a)
sequenceA t (f a)
t (f (f b))
x)
  {-# INLINE gtraverse_ #-}