{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
#ifdef TRUSTWORTHY
{-# LANGUAGE Trustworthy #-}
#endif
#ifndef MIN_VERSION_base
#define MIN_VERSION_base(x,y,z) 1
#endif
#ifndef MIN_VERSION_containers
#define MIN_VERSION_containers(x,y,z) 1
#endif
module Control.Lens.Indexed
(
Indexable(..)
, Conjoined(..)
, Indexed(..)
, (<.), (<.>), (.>)
, selfIndex
, reindexed
, icompose
, indexing
, indexing64
, FunctorWithIndex(..)
, FoldableWithIndex(..)
, iany
, iall
, inone, none
, itraverse_
, ifor_
, imapM_
, iforM_
, iconcatMap
, ifind
, ifoldrM
, ifoldlM
, itoList
, withIndex
, asIndex
, indices
, index
, TraversableWithIndex(..)
, ifor
, imapM
, iforM
, imapAccumR
, imapAccumL
, ifoldMapBy
, ifoldMapByOf
, itraverseBy
, itraverseByOf
) where
import Control.Applicative
import Control.Applicative.Backwards
import Control.Comonad.Cofree
import Control.Comonad.Trans.Traced
import Control.Monad (void, liftM)
import Control.Monad.Trans.Identity
import Control.Monad.Trans.Reader
import Control.Monad.Trans.State.Lazy as Lazy
import Control.Monad.Free
import Control.Lens.Fold
import Control.Lens.Getter
import Control.Lens.Internal.Fold
import Control.Lens.Internal.Indexed
import Control.Lens.Internal.Level
import Control.Lens.Internal.Magma
import Control.Lens.Setter
import Control.Lens.Traversal
import Control.Lens.Type
import Data.Array (Array)
import qualified Data.Array as Array
import Data.Foldable
import Data.Functor.Compose
import Data.Functor.Contravariant
import Data.Functor.Product
import Data.Functor.Reverse
import Data.Functor.Sum
import Data.HashMap.Lazy as HashMap
import Data.IntMap as IntMap
import Data.Ix (Ix)
import Data.List.NonEmpty as NonEmpty
import Data.Map as Map
import Data.Monoid hiding (Sum, Product)
import Data.Profunctor.Unsafe
import Data.Proxy
import Data.Reflection
import Data.Sequence hiding ((:<), index)
import Data.Tagged
import Data.Tree
import Data.Tuple (swap)
import Data.Vector (Vector)
import Data.Void
import qualified Data.Vector as V
import GHC.Generics
import Prelude
#if !(MIN_VERSION_base(4,8,0))
import Data.Traversable (sequenceA)
#endif
#ifdef HLINT
{-# ANN module "HLint: ignore Use fmap" #-}
#endif
infixr 9 <.>, <., .>
(<.) :: Indexable i p => (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r
<. :: (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r
(<.) f :: Indexed i s t -> r
f g :: (a -> b) -> s -> t
g h :: p a b
h = Indexed i s t -> r
f (Indexed i s t -> r)
-> ((i -> s -> t) -> Indexed i s t) -> (i -> s -> t) -> r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> s -> t) -> Indexed i s t
forall i a b. (i -> a -> b) -> Indexed i a b
Indexed ((i -> s -> t) -> r) -> (i -> s -> t) -> r
forall a b. (a -> b) -> a -> b
$ (a -> b) -> s -> t
g ((a -> b) -> s -> t) -> (i -> a -> b) -> i -> s -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p a b -> i -> a -> b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed p a b
h
{-# INLINE (<.) #-}
(.>) :: (st -> r) -> (kab -> st) -> kab -> r
.> :: (st -> r) -> (kab -> st) -> kab -> r
(.>) = (st -> r) -> (kab -> st) -> kab -> r
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.)
{-# INLINE (.>) #-}
selfIndex :: Indexable a p => p a fb -> a -> fb
selfIndex :: p a fb -> a -> fb
selfIndex f :: p a fb
f a :: a
a = p a fb -> a -> a -> fb
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed p a fb
f a
a a
a
{-# INLINE selfIndex #-}
reindexed :: Indexable j p => (i -> j) -> (Indexed i a b -> r) -> p a b -> r
reindexed :: (i -> j) -> (Indexed i a b -> r) -> p a b -> r
reindexed ij :: i -> j
ij f :: Indexed i a b -> r
f g :: p a b
g = Indexed i a b -> r
f (Indexed i a b -> r)
-> ((i -> a -> b) -> Indexed i a b) -> (i -> a -> b) -> r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> b) -> Indexed i a b
forall i a b. (i -> a -> b) -> Indexed i a b
Indexed ((i -> a -> b) -> r) -> (i -> a -> b) -> r
forall a b. (a -> b) -> a -> b
$ p a b -> j -> a -> b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed p a b
g (j -> a -> b) -> (i -> j) -> i -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> j
ij
{-# INLINE reindexed #-}
(<.>) :: Indexable (i, j) p => (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> p a b -> r
f :: Indexed i s t -> r
f <.> :: (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> p a b -> r
<.> g :: Indexed j a b -> s -> t
g = (i -> j -> (i, j))
-> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> p a b -> r
forall p (c :: * -> * -> *) i j s t r a b.
Indexable p c =>
(i -> j -> p)
-> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r
icompose (,) Indexed i s t -> r
f Indexed j a b -> s -> t
g
{-# INLINE (<.>) #-}
icompose :: Indexable p c => (i -> j -> p) -> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r
icompose :: (i -> j -> p)
-> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r
icompose ijk :: i -> j -> p
ijk istr :: Indexed i s t -> r
istr jabst :: Indexed j a b -> s -> t
jabst cab :: c a b
cab = Indexed i s t -> r
istr (Indexed i s t -> r)
-> ((i -> s -> t) -> Indexed i s t) -> (i -> s -> t) -> r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> s -> t) -> Indexed i s t
forall i a b. (i -> a -> b) -> Indexed i a b
Indexed ((i -> s -> t) -> r) -> (i -> s -> t) -> r
forall a b. (a -> b) -> a -> b
$ \i :: i
i -> Indexed j a b -> s -> t
jabst (Indexed j a b -> s -> t)
-> ((j -> a -> b) -> Indexed j a b) -> (j -> a -> b) -> s -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (j -> a -> b) -> Indexed j a b
forall i a b. (i -> a -> b) -> Indexed i a b
Indexed ((j -> a -> b) -> s -> t) -> (j -> a -> b) -> s -> t
forall a b. (a -> b) -> a -> b
$ \j :: j
j -> c a b -> p -> a -> b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed c a b
cab (p -> a -> b) -> p -> a -> b
forall a b. (a -> b) -> a -> b
$ i -> j -> p
ijk i
i j
j
{-# INLINE icompose #-}
indices :: (Indexable i p, Applicative f) => (i -> Bool) -> Optical' p (Indexed i) f a a
indices :: (i -> Bool) -> Optical' p (Indexed i) f a a
indices p :: i -> Bool
p f :: p a (f a)
f = (i -> a -> f a) -> Indexed i a (f a)
forall i a b. (i -> a -> b) -> Indexed i a b
Indexed ((i -> a -> f a) -> Indexed i a (f a))
-> (i -> a -> f a) -> Indexed i a (f a)
forall a b. (a -> b) -> a -> b
$ \i :: i
i a :: a
a -> if i -> Bool
p i
i then p a (f a) -> i -> a -> f a
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed p a (f a)
f i
i a
a else a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a
{-# INLINE indices #-}
index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p (Indexed i) f a a
index :: i -> Optical' p (Indexed i) f a a
index j :: i
j f :: p a (f a)
f = (i -> a -> f a) -> Indexed i a (f a)
forall i a b. (i -> a -> b) -> Indexed i a b
Indexed ((i -> a -> f a) -> Indexed i a (f a))
-> (i -> a -> f a) -> Indexed i a (f a)
forall a b. (a -> b) -> a -> b
$ \i :: i
i a :: a
a -> if i
j i -> i -> Bool
forall a. Eq a => a -> a -> Bool
== i
i then p a (f a) -> i -> a -> f a
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed p a (f a)
f i
i a
a else a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a
{-# INLINE index #-}
class Functor f => FunctorWithIndex i f | f -> i where
imap :: (i -> a -> b) -> f a -> f b
default imap :: TraversableWithIndex i f => (i -> a -> b) -> f a -> f b
imap = AnIndexedSetter i (f a) (f b) a b -> (i -> a -> b) -> f a -> f b
forall i s t a b.
AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
iover AnIndexedSetter i (f a) (f b) a b
forall i (t :: * -> *) a b.
TraversableWithIndex i t =>
IndexedTraversal i (t a) (t b) a b
itraversed
{-# INLINE imap #-}
imapped :: IndexedSetter i (f a) (f b) a b
imapped = ((p ~ (->)) => (a -> f b) -> f a -> f (f b))
-> (p a (f b) -> f a -> f (f b)) -> p a (f b) -> f a -> f (f b)
forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
Conjoined p =>
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
conjoined (p ~ (->)) => (a -> f b) -> f a -> f (f b)
forall (f :: * -> *) a b. Functor f => Setter (f a) (f b) a b
mapped (((i -> a -> b) -> f a -> f b) -> IndexedSetter i (f a) (f b) a b
forall i a b s t.
((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b
isets (i -> a -> b) -> f a -> f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap)
{-# INLINE imapped #-}
class Foldable f => FoldableWithIndex i f | f -> i where
ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m
#ifndef HLINT
default ifoldMap :: (TraversableWithIndex i f, Monoid m) => (i -> a -> m) -> f a -> m
ifoldMap = IndexedGetting i m (f a) a -> (i -> a -> m) -> f a -> m
forall i m s a. IndexedGetting i m s a -> (i -> a -> m) -> s -> m
ifoldMapOf IndexedGetting i m (f a) a
forall i (t :: * -> *) a b.
TraversableWithIndex i t =>
IndexedTraversal i (t a) (t b) a b
itraversed
{-# INLINE ifoldMap #-}
#endif
ifolded :: IndexedFold i (f a) a
ifolded = ((p ~ (->)) => (a -> f a) -> f a -> f (f a))
-> (p a (f a) -> f a -> f (f a)) -> p a (f a) -> f a -> f (f a)
forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
Conjoined p =>
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
conjoined (p ~ (->)) => (a -> f a) -> f a -> f (f a)
forall (f :: * -> *) a. Foldable f => IndexedFold Int (f a) a
folded ((p a (f a) -> f a -> f (f a)) -> p a (f a) -> f a -> f (f a))
-> (p a (f a) -> f a -> f (f a)) -> p a (f a) -> f a -> f (f a)
forall a b. (a -> b) -> a -> b
$ \f :: p a (f a)
f -> f a -> f (f a)
forall (f :: * -> *) a b.
(Functor f, Contravariant f) =>
f a -> f b
phantom (f a -> f (f a)) -> (f a -> f a) -> f a -> f (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Folding f a -> f a
forall (f :: * -> *) a. Folding f a -> f a
getFolding (Folding f a -> f a) -> (f a -> Folding f a) -> f a -> f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> Folding f a) -> f a -> Folding f a
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> f a -> Folding f a
forall (f :: * -> *) a. f a -> Folding f a
Folding (f a -> Folding f a) -> (a -> f a) -> a -> Folding f a
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. p a (f a) -> i -> a -> f a
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed p a (f a)
f i
i)
{-# INLINE ifolded #-}
ifoldr :: (i -> a -> b -> b) -> b -> f a -> b
ifoldr f :: i -> a -> b -> b
f z :: b
z t :: f a
t = Endo b -> b -> b
forall a. Endo a -> a -> a
appEndo ((i -> a -> Endo b) -> f a -> Endo b
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> (b -> b) -> Endo b
forall a. (a -> a) -> Endo a
Endo ((b -> b) -> Endo b) -> (a -> b -> b) -> a -> Endo b
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. i -> a -> b -> b
f i
i) f a
t) b
z
{-# INLINE ifoldr #-}
ifoldl :: (i -> b -> a -> b) -> b -> f a -> b
ifoldl f :: i -> b -> a -> b
f z :: b
z t :: 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 ((i -> a -> Dual (Endo b)) -> f a -> Dual (Endo b)
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> Endo b -> Dual (Endo b)
forall a. a -> Dual a
Dual (Endo b -> Dual (Endo b)) -> (a -> Endo b) -> a -> Dual (Endo b)
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. (b -> b) -> Endo b
forall a. (a -> a) -> Endo a
Endo ((b -> b) -> Endo b) -> (a -> b -> b) -> a -> Endo b
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. (b -> a -> b) -> a -> b -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip (i -> b -> a -> b
f i
i)) f a
t)) b
z
{-# INLINE ifoldl #-}
ifoldr' :: (i -> a -> b -> b) -> b -> f a -> b
ifoldr' f :: i -> a -> b -> b
f z0 :: b
z0 xs :: f a
xs = (i -> (b -> b) -> a -> b -> b) -> (b -> b) -> f a -> b -> b
forall i (f :: * -> *) b a.
FoldableWithIndex i f =>
(i -> b -> a -> b) -> b -> f a -> b
ifoldl i -> (b -> b) -> a -> b -> b
f' b -> b
forall a. a -> a
id f a
xs b
z0
where f' :: i -> (b -> b) -> a -> b -> b
f' i :: i
i k :: b -> b
k x :: a
x z :: b
z = b -> b
k (b -> b) -> b -> b
forall a b. (a -> b) -> a -> b
$! i -> a -> b -> b
f i
i a
x b
z
{-# INLINE ifoldr' #-}
ifoldl' :: (i -> b -> a -> b) -> b -> f a -> b
ifoldl' f :: i -> b -> a -> b
f z0 :: b
z0 xs :: f a
xs = (i -> a -> (b -> b) -> b -> b) -> (b -> b) -> f a -> b -> b
forall i (f :: * -> *) a b.
FoldableWithIndex i f =>
(i -> a -> b -> b) -> b -> f a -> b
ifoldr i -> a -> (b -> b) -> b -> b
f' b -> b
forall a. a -> a
id f a
xs b
z0
where f' :: i -> a -> (b -> b) -> b -> b
f' i :: i
i x :: a
x k :: b -> b
k z :: b
z = b -> b
k (b -> b) -> b -> b
forall a b. (a -> b) -> a -> b
$! i -> b -> a -> b
f i
i b
z a
x
{-# INLINE ifoldl' #-}
iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
iany :: (i -> a -> Bool) -> f a -> Bool
iany f :: i -> a -> Bool
f = Any -> Bool
getAny (Any -> Bool) -> (f a -> Any) -> f a -> Bool
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. (i -> a -> Any) -> f a -> Any
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> Bool -> Any
Any (Bool -> Any) -> (a -> Bool) -> a -> Any
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. i -> a -> Bool
f i
i)
{-# INLINE iany #-}
iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
iall :: (i -> a -> Bool) -> f a -> Bool
iall f :: i -> a -> Bool
f = All -> Bool
getAll (All -> Bool) -> (f a -> All) -> f a -> Bool
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. (i -> a -> All) -> f a -> All
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> Bool -> All
All (Bool -> All) -> (a -> Bool) -> a -> All
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. i -> a -> Bool
f i
i)
{-# INLINE iall #-}
inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
inone :: (i -> a -> Bool) -> f a -> Bool
inone f :: i -> a -> Bool
f = Bool -> Bool
not (Bool -> Bool) -> (f a -> Bool) -> f a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> Bool) -> f a -> Bool
forall i (f :: * -> *) a.
FoldableWithIndex i f =>
(i -> a -> Bool) -> f a -> Bool
iany i -> a -> Bool
f
{-# INLINE inone #-}
none :: Foldable f => (a -> Bool) -> f a -> Bool
none :: (a -> Bool) -> f a -> Bool
none f :: a -> Bool
f = Bool -> Bool
not (Bool -> Bool) -> (f a -> Bool) -> f a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> f a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
Data.Foldable.any a -> Bool
f
{-# INLINE none #-}
itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f ()
itraverse_ :: (i -> a -> f b) -> t a -> f ()
itraverse_ f :: i -> a -> f b
f = f b -> f ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (f b -> f ()) -> (t a -> f b) -> t a -> f ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Traversed b f -> f b
forall a (f :: * -> *). Traversed a f -> f a
getTraversed (Traversed b f -> f b) -> (t a -> Traversed b f) -> t a -> f b
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. (i -> a -> Traversed b f) -> t a -> Traversed b f
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> f b -> Traversed b f
forall a (f :: * -> *). f a -> Traversed a f
Traversed (f b -> Traversed b f) -> (a -> f b) -> a -> Traversed b f
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. i -> a -> f b
f i
i)
{-# INLINE itraverse_ #-}
ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f ()
ifor_ :: t a -> (i -> a -> f b) -> f ()
ifor_ = ((i -> a -> f b) -> t a -> f ()) -> t a -> (i -> a -> f b) -> f ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (i -> a -> f b) -> t a -> f ()
forall i (t :: * -> *) (f :: * -> *) a b.
(FoldableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f ()
itraverse_
{-# INLINE ifor_ #-}
imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m ()
imapM_ :: (i -> a -> m b) -> t a -> m ()
imapM_ f :: i -> a -> m b
f = (b -> ()) -> m b -> m ()
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM b -> ()
forall a. a -> ()
skip (m b -> m ()) -> (t a -> m b) -> t a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sequenced b m -> m b
forall a (m :: * -> *). Sequenced a m -> m a
getSequenced (Sequenced b m -> m b) -> (t a -> Sequenced b m) -> t a -> m b
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. (i -> a -> Sequenced b m) -> t a -> Sequenced b m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> m b -> Sequenced b m
forall a (m :: * -> *). m a -> Sequenced a m
Sequenced (m b -> Sequenced b m) -> (a -> m b) -> a -> Sequenced b m
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. i -> a -> m b
f i
i)
{-# INLINE imapM_ #-}
iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m ()
iforM_ :: t a -> (i -> a -> m b) -> m ()
iforM_ = ((i -> a -> m b) -> t a -> m ()) -> t a -> (i -> a -> m b) -> m ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (i -> a -> m b) -> t a -> m ()
forall i (t :: * -> *) (m :: * -> *) a b.
(FoldableWithIndex i t, Monad m) =>
(i -> a -> m b) -> t a -> m ()
imapM_
{-# INLINE iforM_ #-}
iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b]
iconcatMap :: (i -> a -> [b]) -> f a -> [b]
iconcatMap = (i -> a -> [b]) -> f a -> [b]
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap
{-# INLINE iconcatMap #-}
ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a)
ifind :: (i -> a -> Bool) -> f a -> Maybe (i, a)
ifind p :: i -> a -> Bool
p = (i -> a -> Maybe (i, a) -> Maybe (i, a))
-> Maybe (i, a) -> f a -> Maybe (i, a)
forall i (f :: * -> *) a b.
FoldableWithIndex i f =>
(i -> a -> b -> b) -> b -> f a -> b
ifoldr (\i :: i
i a :: a
a y :: Maybe (i, a)
y -> if i -> a -> Bool
p i
i a
a then (i, a) -> Maybe (i, a)
forall a. a -> Maybe a
Just (i
i, a
a) else Maybe (i, a)
y) Maybe (i, a)
forall a. Maybe a
Nothing
{-# INLINE ifind #-}
ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b
ifoldrM :: (i -> a -> b -> m b) -> b -> f a -> m b
ifoldrM f :: i -> a -> b -> m b
f z0 :: b
z0 xs :: f a
xs = (i -> (b -> m b) -> a -> b -> m b) -> (b -> m b) -> f a -> b -> m b
forall i (f :: * -> *) b a.
FoldableWithIndex i f =>
(i -> b -> a -> b) -> b -> f a -> b
ifoldl i -> (b -> m b) -> a -> b -> m b
f' b -> m b
forall (m :: * -> *) a. Monad m => a -> m a
return f a
xs b
z0
where f' :: i -> (b -> m b) -> a -> b -> m b
f' i :: i
i k :: b -> m b
k x :: a
x z :: b
z = i -> a -> b -> m b
f i
i a
x b
z m b -> (b -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> m b
k
{-# INLINE ifoldrM #-}
ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b
ifoldlM :: (i -> b -> a -> m b) -> b -> f a -> m b
ifoldlM f :: i -> b -> a -> m b
f z0 :: b
z0 xs :: f a
xs = (i -> a -> (b -> m b) -> b -> m b) -> (b -> m b) -> f a -> b -> m b
forall i (f :: * -> *) a b.
FoldableWithIndex i f =>
(i -> a -> b -> b) -> b -> f a -> b
ifoldr i -> a -> (b -> m b) -> b -> m b
f' b -> m b
forall (m :: * -> *) a. Monad m => a -> m a
return f a
xs b
z0
where f' :: i -> a -> (b -> m b) -> b -> m b
f' i :: i
i x :: a
x k :: b -> m b
k z :: b
z = i -> b -> a -> m b
f i
i b
z a
x m b -> (b -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> m b
k
{-# INLINE ifoldlM #-}
itoList :: FoldableWithIndex i f => f a -> [(i,a)]
itoList :: f a -> [(i, a)]
itoList = (i -> a -> [(i, a)] -> [(i, a)]) -> [(i, a)] -> f a -> [(i, a)]
forall i (f :: * -> *) a b.
FoldableWithIndex i f =>
(i -> a -> b -> b) -> b -> f a -> b
ifoldr (\i :: i
i c :: a
c -> ((i
i,a
c)(i, a) -> [(i, a)] -> [(i, a)]
forall a. a -> [a] -> [a]
:)) []
{-# INLINE itoList #-}
class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i t | t -> i where
itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b)
#ifndef HLINT
default itraverse :: (i ~ Int, Applicative f) => (i -> a -> f b) -> t a -> f (t b)
itraverse = Indexed Int a (f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
traversed (Indexed Int a (f b) -> t a -> f (t b))
-> ((Int -> a -> f b) -> Indexed Int a (f b))
-> (Int -> a -> f b)
-> t a
-> f (t b)
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible b a) =>
p b c -> q a b -> p a c
.# (Int -> a -> f b) -> Indexed Int a (f b)
forall i a b. (i -> a -> b) -> Indexed i a b
Indexed
{-# INLINE itraverse #-}
#endif
itraversed :: IndexedTraversal i (t a) (t b) a b
itraversed = ((p ~ (->)) => (a -> f b) -> t a -> f (t b))
-> (p a (f b) -> t a -> f (t b)) -> p a (f b) -> t a -> f (t b)
forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
Conjoined p =>
((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
conjoined (p ~ (->)) => (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)
traverse ((i -> a -> f b) -> t a -> f (t b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse ((i -> a -> f b) -> t a -> f (t b))
-> (p a (f b) -> i -> a -> f b) -> p a (f b) -> t a -> f (t b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p a (f b) -> i -> a -> f b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed)
{-# INLINE itraversed #-}
ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b)
ifor :: t a -> (i -> a -> f b) -> f (t b)
ifor = ((i -> a -> f b) -> t a -> f (t b))
-> t a -> (i -> a -> f b) -> f (t b)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (i -> a -> f b) -> t a -> f (t b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse
{-# INLINE ifor #-}
imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)
imapM :: (i -> a -> m b) -> t a -> m (t b)
imapM f :: i -> a -> m b
f = WrappedMonad m (t b) -> m (t b)
forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad (WrappedMonad m (t b) -> m (t b))
-> (t a -> WrappedMonad m (t b)) -> t a -> m (t b)
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. (i -> a -> WrappedMonad m b) -> t a -> WrappedMonad m (t b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\i :: i
i -> m b -> WrappedMonad m b
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m b -> WrappedMonad m b) -> (a -> m b) -> a -> WrappedMonad m b
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. i -> a -> m b
f i
i)
{-# INLINE imapM #-}
iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b)
iforM :: t a -> (i -> a -> m b) -> m (t b)
iforM = ((i -> a -> m b) -> t a -> m (t b))
-> t a -> (i -> a -> m b) -> m (t b)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (i -> a -> m b) -> t a -> m (t b)
forall i (t :: * -> *) (m :: * -> *) a b.
(TraversableWithIndex i t, Monad m) =>
(i -> a -> m b) -> t a -> m (t b)
imapM
{-# INLINE iforM #-}
imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
imapAccumR :: (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
imapAccumR f :: i -> s -> a -> (s, b)
f s0 :: s
s0 a :: t a
a = (t b, s) -> (s, t b)
forall a b. (a, b) -> (b, a)
swap (State s (t b) -> s -> (t b, s)
forall s a. State s a -> s -> (a, s)
Lazy.runState (Backwards (StateT s Identity) (t b) -> State s (t b)
forall k (f :: k -> *) (a :: k). Backwards f a -> f a
forwards ((i -> a -> Backwards (StateT s Identity) b)
-> t a -> Backwards (StateT s Identity) (t b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\i :: i
i c :: a
c -> StateT s Identity b -> Backwards (StateT s Identity) b
forall k (f :: k -> *) (a :: k). f a -> Backwards f a
Backwards ((s -> (b, s)) -> StateT s Identity b
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
Lazy.state (\s :: s
s -> (s, b) -> (b, s)
forall a b. (a, b) -> (b, a)
swap (i -> s -> a -> (s, b)
f i
i s
s a
c)))) t a
a)) s
s0)
{-# INLINE imapAccumR #-}
imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
imapAccumL :: (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
imapAccumL f :: i -> s -> a -> (s, b)
f s0 :: s
s0 a :: t a
a = (t b, s) -> (s, t b)
forall a b. (a, b) -> (b, a)
swap (State s (t b) -> s -> (t b, s)
forall s a. State s a -> s -> (a, s)
Lazy.runState ((i -> a -> StateT s Identity b) -> t a -> State s (t b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\i :: i
i c :: a
c -> (s -> (b, s)) -> StateT s Identity b
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
Lazy.state (\s :: s
s -> (s, b) -> (b, s)
forall a b. (a, b) -> (b, a)
swap (i -> s -> a -> (s, b)
f i
i s
s a
c))) t a
a) s
s0)
{-# INLINE imapAccumL #-}
instance FunctorWithIndex i f => FunctorWithIndex i (Backwards f) where
imap :: (i -> a -> b) -> Backwards f a -> Backwards f b
imap f :: i -> a -> b
f = f b -> Backwards f b
forall k (f :: k -> *) (a :: k). f a -> Backwards f a
Backwards (f b -> Backwards f b)
-> (Backwards f a -> f b) -> Backwards f a -> Backwards f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> b) -> f a -> f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap i -> a -> b
f (f a -> f b) -> (Backwards f a -> f a) -> Backwards f a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Backwards f a -> f a
forall k (f :: k -> *) (a :: k). Backwards f a -> f a
forwards
{-# INLINE imap #-}
instance FoldableWithIndex i f => FoldableWithIndex i (Backwards f) where
ifoldMap :: (i -> a -> m) -> Backwards f a -> m
ifoldMap f :: i -> a -> m
f = (i -> a -> m) -> f a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap i -> a -> m
f (f a -> m) -> (Backwards f a -> f a) -> Backwards f a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Backwards f a -> f a
forall k (f :: k -> *) (a :: k). Backwards f a -> f a
forwards
{-# INLINE ifoldMap #-}
instance TraversableWithIndex i f => TraversableWithIndex i (Backwards f) where
itraverse :: (i -> a -> f b) -> Backwards f a -> f (Backwards f b)
itraverse f :: i -> a -> f b
f = (f b -> Backwards f b) -> f (f b) -> f (Backwards f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f b -> Backwards f b
forall k (f :: k -> *) (a :: k). f a -> Backwards f a
Backwards (f (f b) -> f (Backwards f b))
-> (Backwards f a -> f (f b)) -> Backwards f a -> f (Backwards f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> f b) -> f a -> f (f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse i -> a -> f b
f (f a -> f (f b))
-> (Backwards f a -> f a) -> Backwards f a -> f (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Backwards f a -> f a
forall k (f :: k -> *) (a :: k). Backwards f a -> f a
forwards
{-# INLINE itraverse #-}
instance FunctorWithIndex i f => FunctorWithIndex i (Reverse f) where
imap :: (i -> a -> b) -> Reverse f a -> Reverse f b
imap f :: i -> a -> b
f = f b -> Reverse f b
forall k (f :: k -> *) (a :: k). f a -> Reverse f a
Reverse (f b -> Reverse f b)
-> (Reverse f a -> f b) -> Reverse f a -> Reverse f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> b) -> f a -> f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap i -> a -> b
f (f a -> f b) -> (Reverse f a -> f a) -> Reverse f a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reverse f a -> f a
forall k (f :: k -> *) (a :: k). Reverse f a -> f a
getReverse
{-# INLINE imap #-}
instance FoldableWithIndex i f => FoldableWithIndex i (Reverse f) where
ifoldMap :: (i -> a -> m) -> Reverse f a -> m
ifoldMap f :: i -> a -> m
f = Dual m -> m
forall a. Dual a -> a
getDual (Dual m -> m) -> (Reverse f a -> Dual m) -> Reverse f a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> Dual m) -> f a -> Dual m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> m -> Dual m
forall a. a -> Dual a
Dual (m -> Dual m) -> (a -> m) -> a -> Dual m
forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
(Profunctor p, Coercible c b) =>
q b c -> p a b -> p a c
#. i -> a -> m
f i
i) (f a -> Dual m) -> (Reverse f a -> f a) -> Reverse f a -> Dual m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reverse f a -> f a
forall k (f :: k -> *) (a :: k). Reverse f a -> f a
getReverse
{-# INLINE ifoldMap #-}
instance TraversableWithIndex i f => TraversableWithIndex i (Reverse f) where
itraverse :: (i -> a -> f b) -> Reverse f a -> f (Reverse f b)
itraverse f :: i -> a -> f b
f = (f b -> Reverse f b) -> f (f b) -> f (Reverse f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f b -> Reverse f b
forall k (f :: k -> *) (a :: k). f a -> Reverse f a
Reverse (f (f b) -> f (Reverse f b))
-> (Reverse f a -> f (f b)) -> Reverse f a -> f (Reverse f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Backwards f (f b) -> f (f b)
forall k (f :: k -> *) (a :: k). Backwards f a -> f a
forwards (Backwards f (f b) -> f (f b))
-> (Reverse f a -> Backwards f (f b)) -> Reverse f a -> f (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> Backwards f b) -> f a -> Backwards f (f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\i :: i
i -> f b -> Backwards f b
forall k (f :: k -> *) (a :: k). f a -> Backwards f a
Backwards (f b -> Backwards f b) -> (a -> f b) -> a -> Backwards f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> a -> f b
f i
i) (f a -> Backwards f (f b))
-> (Reverse f a -> f a) -> Reverse f a -> Backwards f (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reverse f a -> f a
forall k (f :: k -> *) (a :: k). Reverse f a -> f a
getReverse
{-# INLINE itraverse #-}
instance FunctorWithIndex () Identity where
imap :: (() -> a -> b) -> Identity a -> Identity b
imap f :: () -> a -> b
f (Identity a :: a
a) = b -> Identity b
forall a. a -> Identity a
Identity (() -> a -> b
f () a
a)
{-# INLINE imap #-}
instance FoldableWithIndex () Identity where
ifoldMap :: (() -> a -> m) -> Identity a -> m
ifoldMap f :: () -> a -> m
f (Identity a :: a
a) = () -> a -> m
f () a
a
{-# INLINE ifoldMap #-}
instance TraversableWithIndex () Identity where
itraverse :: (() -> a -> f b) -> Identity a -> f (Identity b)
itraverse f :: () -> a -> f b
f (Identity a :: a
a) = b -> Identity b
forall a. a -> Identity a
Identity (b -> Identity b) -> f b -> f (Identity b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> () -> a -> f b
f () a
a
{-# INLINE itraverse #-}
instance FunctorWithIndex k ((,) k) where
imap :: (k -> a -> b) -> (k, a) -> (k, b)
imap f :: k -> a -> b
f (k :: k
k,a :: a
a) = (k
k, k -> a -> b
f k
k a
a)
{-# INLINE imap #-}
instance FoldableWithIndex k ((,) k) where
ifoldMap :: (k -> a -> m) -> (k, a) -> m
ifoldMap = (k -> a -> m) -> (k, a) -> m
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry
{-# INLINE ifoldMap #-}
instance TraversableWithIndex k ((,) k) where
itraverse :: (k -> a -> f b) -> (k, a) -> f (k, b)
itraverse f :: k -> a -> f b
f (k :: k
k, a :: a
a) = (,) k
k (b -> (k, b)) -> f b -> f (k, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k -> a -> f b
f k
k a
a
{-# INLINE itraverse #-}
instance FunctorWithIndex Int []
instance FoldableWithIndex Int []
instance TraversableWithIndex Int [] where
itraversed :: p a (f b) -> [a] -> f [b]
itraversed = p a (f b) -> [a] -> f [b]
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
traversed
{-# INLINE itraversed #-}
instance FunctorWithIndex Int ZipList
instance FoldableWithIndex Int ZipList
instance TraversableWithIndex Int ZipList where
itraversed :: p a (f b) -> ZipList a -> f (ZipList b)
itraversed = p a (f b) -> ZipList a -> f (ZipList b)
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
traversed
{-# INLINE itraversed #-}
instance FunctorWithIndex Int NonEmpty
instance FoldableWithIndex Int NonEmpty
instance TraversableWithIndex Int NonEmpty where
itraverse :: (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b)
itraverse = (Indexed Int a (f b) -> NonEmpty a -> f (NonEmpty b))
-> (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b)
forall i a (f :: * -> *) b s t.
(Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t
itraverseOf Indexed Int a (f b) -> NonEmpty a -> f (NonEmpty b)
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
traversed
{-# INLINE itraverse #-}
instance FunctorWithIndex () Maybe where
imap :: (() -> a -> b) -> Maybe a -> Maybe b
imap f :: () -> a -> b
f = (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (() -> a -> b
f ())
{-# INLINE imap #-}
instance FoldableWithIndex () Maybe where
ifoldMap :: (() -> a -> m) -> Maybe a -> m
ifoldMap f :: () -> a -> m
f = (a -> m) -> Maybe a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (() -> a -> m
f ())
{-# INLINE ifoldMap #-}
instance TraversableWithIndex () Maybe where
itraverse :: (() -> a -> f b) -> Maybe a -> f (Maybe b)
itraverse f :: () -> a -> f b
f = (a -> f b) -> Maybe a -> f (Maybe b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (() -> a -> f b
f ())
{-# INLINE itraverse #-}
instance FunctorWithIndex Int Seq where
imap :: (Int -> a -> b) -> Seq a -> Seq b
imap = (Int -> a -> b) -> Seq a -> Seq b
forall a b. (Int -> a -> b) -> Seq a -> Seq b
mapWithIndex
instance FoldableWithIndex Int Seq where
#if MIN_VERSION_containers(0,5,8)
ifoldMap :: (Int -> a -> m) -> Seq a -> m
ifoldMap = (Int -> a -> m) -> Seq a -> m
forall m a. Monoid m => (Int -> a -> m) -> Seq a -> m
foldMapWithIndex
#else
ifoldMap f = Data.Foldable.fold . mapWithIndex f
#endif
ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b
ifoldr = (Int -> a -> b -> b) -> b -> Seq a -> b
forall a b. (Int -> a -> b -> b) -> b -> Seq a -> b
foldrWithIndex
ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b
ifoldl f :: Int -> b -> a -> b
f = (b -> Int -> a -> b) -> b -> Seq a -> b
forall b a. (b -> Int -> a -> b) -> b -> Seq a -> b
foldlWithIndex ((Int -> b -> a -> b) -> b -> Int -> a -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> b -> a -> b
f)
{-# INLINE ifoldl #-}
instance TraversableWithIndex Int Seq where
#if MIN_VERSION_containers(0,5,8)
itraverse :: (Int -> a -> f b) -> Seq a -> f (Seq b)
itraverse = (Int -> a -> f b) -> Seq a -> f (Seq b)
forall (f :: * -> *) a b.
Applicative f =>
(Int -> a -> f b) -> Seq a -> f (Seq b)
traverseWithIndex
#else
itraverse f = sequenceA . mapWithIndex f
#endif
instance FunctorWithIndex Int Vector where
imap :: (Int -> a -> b) -> Vector a -> Vector b
imap = (Int -> a -> b) -> Vector a -> Vector b
forall a b. (Int -> a -> b) -> Vector a -> Vector b
V.imap
{-# INLINE imap #-}
instance FoldableWithIndex Int Vector where
ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b
ifoldr = (Int -> a -> b -> b) -> b -> Vector a -> b
forall a b. (Int -> a -> b -> b) -> b -> Vector a -> b
V.ifoldr
{-# INLINE ifoldr #-}
ifoldl :: (Int -> b -> a -> b) -> b -> Vector a -> b
ifoldl = (b -> Int -> a -> b) -> b -> Vector a -> b
forall a b. (a -> Int -> b -> a) -> a -> Vector b -> a
V.ifoldl ((b -> Int -> a -> b) -> b -> Vector a -> b)
-> ((Int -> b -> a -> b) -> b -> Int -> a -> b)
-> (Int -> b -> a -> b)
-> b
-> Vector a
-> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> b -> a -> b) -> b -> Int -> a -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip
{-# INLINE ifoldl #-}
ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b
ifoldr' = (Int -> a -> b -> b) -> b -> Vector a -> b
forall a b. (Int -> a -> b -> b) -> b -> Vector a -> b
V.ifoldr'
{-# INLINE ifoldr' #-}
ifoldl' :: (Int -> b -> a -> b) -> b -> Vector a -> b
ifoldl' = (b -> Int -> a -> b) -> b -> Vector a -> b
forall a b. (a -> Int -> b -> a) -> a -> Vector b -> a
V.ifoldl' ((b -> Int -> a -> b) -> b -> Vector a -> b)
-> ((Int -> b -> a -> b) -> b -> Int -> a -> b)
-> (Int -> b -> a -> b)
-> b
-> Vector a
-> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> b -> a -> b) -> b -> Int -> a -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip
{-# INLINE ifoldl' #-}
instance TraversableWithIndex Int Vector where
itraversed :: p a (f b) -> Vector a -> f (Vector b)
itraversed = p a (f b) -> Vector a -> f (Vector b)
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
traversed
{-# INLINE itraversed #-}
instance FunctorWithIndex Int IntMap
instance FoldableWithIndex Int IntMap
instance TraversableWithIndex Int IntMap where
#if MIN_VERSION_containers(0,5,0)
itraverse :: (Int -> a -> f b) -> IntMap a -> f (IntMap b)
itraverse = (Int -> a -> f b) -> IntMap a -> f (IntMap b)
forall (f :: * -> *) a b.
Applicative f =>
(Int -> a -> f b) -> IntMap a -> f (IntMap b)
IntMap.traverseWithKey
#else
itraverse f = sequenceA . IntMap.mapWithKey f
#endif
{-# INLINE [0] itraverse #-}
{-# RULES
"itraversed -> mapIntMap" itraversed = sets IntMap.map :: ASetter (IntMap a) (IntMap b) a b;
"itraversed -> imapIntMap" itraversed = isets IntMap.mapWithKey :: AnIndexedSetter Int (IntMap a) (IntMap b) a b;
"itraversed -> foldrIntMap" itraversed = foldring IntMap.foldr :: Getting (Endo r) (IntMap a) a;
"itraversed -> ifoldrIntMap" itraversed = ifoldring IntMap.foldrWithKey :: IndexedGetting Int (Endo r) (IntMap a) a;
#-}
instance FunctorWithIndex k (Map k)
instance FoldableWithIndex k (Map k)
instance TraversableWithIndex k (Map k) where
#if MIN_VERSION_containers(0,5,0)
itraverse :: (k -> a -> f b) -> Map k a -> f (Map k b)
itraverse = (k -> a -> f b) -> Map k a -> f (Map k b)
forall (t :: * -> *) k a b.
Applicative t =>
(k -> a -> t b) -> Map k a -> t (Map k b)
Map.traverseWithKey
#else
itraverse f = sequenceA . Map.mapWithKey f
#endif
{-# INLINE [0] itraverse #-}
{-# RULES
"itraversed -> mapMap" itraversed = sets Map.map :: ASetter (Map k a) (Map k b) a b;
"itraversed -> imapMap" itraversed = isets Map.mapWithKey :: AnIndexedSetter k (Map k a) (Map k b) a b;
"itraversed -> foldrMap" itraversed = foldring Map.foldr :: Getting (Endo r) (Map k a) a;
"itraversed -> ifoldrMap" itraversed = ifoldring Map.foldrWithKey :: IndexedGetting k (Endo r) (Map k a) a;
#-}
instance FunctorWithIndex k (HashMap k)
instance FoldableWithIndex k (HashMap k)
instance TraversableWithIndex k (HashMap k) where
itraverse :: (k -> a -> f b) -> HashMap k a -> f (HashMap k b)
itraverse = (k -> a -> f b) -> HashMap k a -> f (HashMap k b)
forall (f :: * -> *) k v1 v2.
Applicative f =>
(k -> v1 -> f v2) -> HashMap k v1 -> f (HashMap k v2)
HashMap.traverseWithKey
{-# INLINE [0] itraverse #-}
{-# RULES
"itraversed -> mapHashMap" itraversed = sets HashMap.map :: ASetter (HashMap k a) (HashMap k b) a b;
"itraversed -> imapHashMap" itraversed = isets HashMap.mapWithKey :: AnIndexedSetter k (HashMap k a) (HashMap k b) a b;
"itraversed -> foldrHashMap" itraversed = foldring HashMap.foldr :: Getting (Endo r) (HashMap k a) a;
"itraversed -> ifoldrHashMap" itraversed = ifoldring HashMap.foldrWithKey :: IndexedGetting k (Endo r) (HashMap k a) a;
#-}
instance FunctorWithIndex r ((->) r) where
imap :: (r -> a -> b) -> (r -> a) -> r -> b
imap f :: r -> a -> b
f g :: r -> a
g x :: r
x = r -> a -> b
f r
x (r -> a
g r
x)
{-# INLINE imap #-}
instance FunctorWithIndex i (Level i) where
imap :: (i -> a -> b) -> Level i a -> Level i b
imap f :: i -> a -> b
f = Level i a -> Level i b
go where
go :: Level i a -> Level i b
go (Two n :: Word
n l :: Level i a
l r :: Level i a
r) = Word -> Level i b -> Level i b -> Level i b
forall i a. Word -> Level i a -> Level i a -> Level i a
Two Word
n (Level i a -> Level i b
go Level i a
l) (Level i a -> Level i b
go Level i a
r)
go (One i :: i
i a :: a
a) = i -> b -> Level i b
forall i a. i -> a -> Level i a
One i
i (i -> a -> b
f i
i a
a)
go Zero = Level i b
forall i a. Level i a
Zero
{-# INLINE imap #-}
instance FoldableWithIndex i (Level i) where
ifoldMap :: (i -> a -> m) -> Level i a -> m
ifoldMap f :: i -> a -> m
f = Level i a -> m
go where
go :: Level i a -> m
go (Two _ l :: Level i a
l r :: Level i a
r) = Level i a -> m
go Level i a
l m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` Level i a -> m
go Level i a
r
go (One i :: i
i a :: a
a) = i -> a -> m
f i
i a
a
go Zero = m
forall a. Monoid a => a
mempty
{-# INLINE ifoldMap #-}
instance TraversableWithIndex i (Level i) where
itraverse :: (i -> a -> f b) -> Level i a -> f (Level i b)
itraverse f :: i -> a -> f b
f = Level i a -> f (Level i b)
go where
go :: Level i a -> f (Level i b)
go (Two n :: Word
n l :: Level i a
l r :: Level i a
r) = Word -> Level i b -> Level i b -> Level i b
forall i a. Word -> Level i a -> Level i a -> Level i a
Two Word
n (Level i b -> Level i b -> Level i b)
-> f (Level i b) -> f (Level i b -> Level i b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Level i a -> f (Level i b)
go Level i a
l f (Level i b -> Level i b) -> f (Level i b) -> f (Level i b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Level i a -> f (Level i b)
go Level i a
r
go (One i :: i
i a :: a
a) = i -> b -> Level i b
forall i a. i -> a -> Level i a
One i
i (b -> Level i b) -> f b -> f (Level i b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> i -> a -> f b
f i
i a
a
go Zero = Level i b -> f (Level i b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Level i b
forall i a. Level i a
Zero
{-# INLINE itraverse #-}
instance FunctorWithIndex i (Magma i t b) where
imap :: (i -> a -> b) -> Magma i t b a -> Magma i t b b
imap f :: i -> a -> b
f (MagmaAp x :: Magma i (x -> t) b a
x y :: Magma i x b a
y) = Magma i (x -> t) b b -> Magma i x b b -> Magma i t b b
forall i x y b a.
Magma i (x -> y) b a -> Magma i x b a -> Magma i y b a
MagmaAp ((i -> a -> b) -> Magma i (x -> t) b a -> Magma i (x -> t) b b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap i -> a -> b
f Magma i (x -> t) b a
x) ((i -> a -> b) -> Magma i x b a -> Magma i x b b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap i -> a -> b
f Magma i x b a
y)
imap _ (MagmaPure x :: t
x) = t -> Magma i t b b
forall x i b a. x -> Magma i x b a
MagmaPure t
x
imap f :: i -> a -> b
f (MagmaFmap xy :: x -> t
xy x :: Magma i x b a
x) = (x -> t) -> Magma i x b b -> Magma i t b b
forall x y i b a. (x -> y) -> Magma i x b a -> Magma i y b a
MagmaFmap x -> t
xy ((i -> a -> b) -> Magma i x b a -> Magma i x b b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap i -> a -> b
f Magma i x b a
x)
imap f :: i -> a -> b
f (Magma i :: i
i a :: a
a) = i -> b -> Magma i t t b
forall i a b. i -> a -> Magma i b b a
Magma i
i (i -> a -> b
f i
i a
a)
{-# INLINE imap #-}
instance FoldableWithIndex i (Magma i t b) where
ifoldMap :: (i -> a -> m) -> Magma i t b a -> m
ifoldMap f :: i -> a -> m
f (MagmaAp x :: Magma i (x -> t) b a
x y :: Magma i x b a
y) = (i -> a -> m) -> Magma i (x -> t) b a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap i -> a -> m
f Magma i (x -> t) b a
x m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (i -> a -> m) -> Magma i x b a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap i -> a -> m
f Magma i x b a
y
ifoldMap _ MagmaPure{} = m
forall a. Monoid a => a
mempty
ifoldMap f :: i -> a -> m
f (MagmaFmap _ x :: Magma i x b a
x) = (i -> a -> m) -> Magma i x b a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap i -> a -> m
f Magma i x b a
x
ifoldMap f :: i -> a -> m
f (Magma i :: i
i a :: a
a) = i -> a -> m
f i
i a
a
{-# INLINE ifoldMap #-}
instance TraversableWithIndex i (Magma i t b) where
itraverse :: (i -> a -> f b) -> Magma i t b a -> f (Magma i t b b)
itraverse f :: i -> a -> f b
f (MagmaAp x :: Magma i (x -> t) b a
x y :: Magma i x b a
y) = Magma i (x -> t) b b -> Magma i x b b -> Magma i t b b
forall i x y b a.
Magma i (x -> y) b a -> Magma i x b a -> Magma i y b a
MagmaAp (Magma i (x -> t) b b -> Magma i x b b -> Magma i t b b)
-> f (Magma i (x -> t) b b) -> f (Magma i x b b -> Magma i t b b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> a -> f b) -> Magma i (x -> t) b a -> f (Magma i (x -> t) b b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse i -> a -> f b
f Magma i (x -> t) b a
x f (Magma i x b b -> Magma i t b b)
-> f (Magma i x b b) -> f (Magma i t b b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (i -> a -> f b) -> Magma i x b a -> f (Magma i x b b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse i -> a -> f b
f Magma i x b a
y
itraverse _ (MagmaPure x :: t
x) = Magma i t b b -> f (Magma i t b b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (t -> Magma i t b b
forall x i b a. x -> Magma i x b a
MagmaPure t
x)
itraverse f :: i -> a -> f b
f (MagmaFmap xy :: x -> t
xy x :: Magma i x b a
x) = (x -> t) -> Magma i x b b -> Magma i t b b
forall x y i b a. (x -> y) -> Magma i x b a -> Magma i y b a
MagmaFmap x -> t
xy (Magma i x b b -> Magma i t b b)
-> f (Magma i x b b) -> f (Magma i t b b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> a -> f b) -> Magma i x b a -> f (Magma i x b b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse i -> a -> f b
f Magma i x b a
x
itraverse f :: i -> a -> f b
f (Magma i :: i
i a :: a
a) = i -> b -> Magma i t t b
forall i a b. i -> a -> Magma i b b a
Magma i
i (b -> Magma i t t b) -> f b -> f (Magma i t t b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> i -> a -> f b
f i
i a
a
{-# INLINE itraverse #-}
instance FunctorWithIndex i f => FunctorWithIndex [i] (Free f) where
imap :: ([i] -> a -> b) -> Free f a -> Free f b
imap f :: [i] -> a -> b
f (Pure a :: a
a) = b -> Free f b
forall (f :: * -> *) a. a -> Free f a
Pure (b -> Free f b) -> b -> Free f b
forall a b. (a -> b) -> a -> b
$ [i] -> a -> b
f [] a
a
imap f :: [i] -> a -> b
f (Free s :: f (Free f a)
s) = f (Free f b) -> Free f b
forall (f :: * -> *) a. f (Free f a) -> Free f a
Free (f (Free f b) -> Free f b) -> f (Free f b) -> Free f b
forall a b. (a -> b) -> a -> b
$ (i -> Free f a -> Free f b) -> f (Free f a) -> f (Free f b)
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (\i :: i
i -> ([i] -> a -> b) -> Free f a -> Free f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap ([i] -> a -> b
f ([i] -> a -> b) -> ([i] -> [i]) -> [i] -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) i
i)) f (Free f a)
s
{-# INLINE imap #-}
instance FoldableWithIndex i f => FoldableWithIndex [i] (Free f) where
ifoldMap :: ([i] -> a -> m) -> Free f a -> m
ifoldMap f :: [i] -> a -> m
f (Pure a :: a
a) = [i] -> a -> m
f [] a
a
ifoldMap f :: [i] -> a -> m
f (Free s :: f (Free f a)
s) = (i -> Free f a -> m) -> f (Free f a) -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> ([i] -> a -> m) -> Free f a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap ([i] -> a -> m
f ([i] -> a -> m) -> ([i] -> [i]) -> [i] -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) i
i)) f (Free f a)
s
{-# INLINE ifoldMap #-}
instance TraversableWithIndex i f => TraversableWithIndex [i] (Free f) where
itraverse :: ([i] -> a -> f b) -> Free f a -> f (Free f b)
itraverse f :: [i] -> a -> f b
f (Pure a :: a
a) = b -> Free f b
forall (f :: * -> *) a. a -> Free f a
Pure (b -> Free f b) -> f b -> f (Free f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [i] -> a -> f b
f [] a
a
itraverse f :: [i] -> a -> f b
f (Free s :: f (Free f a)
s) = f (Free f b) -> Free f b
forall (f :: * -> *) a. f (Free f a) -> Free f a
Free (f (Free f b) -> Free f b) -> f (f (Free f b)) -> f (Free f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> Free f a -> f (Free f b)) -> f (Free f a) -> f (f (Free f b))
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\i :: i
i -> ([i] -> a -> f b) -> Free f a -> f (Free f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse ([i] -> a -> f b
f ([i] -> a -> f b) -> ([i] -> [i]) -> [i] -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) i
i)) f (Free f a)
s
{-# INLINE itraverse #-}
instance Ix i => FunctorWithIndex i (Array i) where
imap :: (i -> a -> b) -> Array i a -> Array i b
imap f :: i -> a -> b
f arr :: Array i a
arr = (i, i) -> [b] -> Array i b
forall i e. Ix i => (i, i) -> [e] -> Array i e
Array.listArray (Array i a -> (i, i)
forall i e. Array i e -> (i, i)
Array.bounds Array i a
arr) ([b] -> Array i b) -> ([(i, a)] -> [b]) -> [(i, a)] -> Array i b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((i, a) -> b) -> [(i, a)] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((i -> a -> b) -> (i, a) -> b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry i -> a -> b
f) ([(i, a)] -> Array i b) -> [(i, a)] -> Array i b
forall a b. (a -> b) -> a -> b
$ Array i a -> [(i, a)]
forall i e. Ix i => Array i e -> [(i, e)]
Array.assocs Array i a
arr
{-# INLINE imap #-}
instance Ix i => FoldableWithIndex i (Array i) where
ifoldMap :: (i -> a -> m) -> Array i a -> m
ifoldMap f :: i -> a -> m
f = ((i, a) -> m) -> [(i, a)] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((i -> a -> m) -> (i, a) -> m
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry i -> a -> m
f) ([(i, a)] -> m) -> (Array i a -> [(i, a)]) -> Array i a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array i a -> [(i, a)]
forall i e. Ix i => Array i e -> [(i, e)]
Array.assocs
{-# INLINE ifoldMap #-}
instance Ix i => TraversableWithIndex i (Array i) where
itraverse :: (i -> a -> f b) -> Array i a -> f (Array i b)
itraverse f :: i -> a -> f b
f arr :: Array i a
arr = (i, i) -> [b] -> Array i b
forall i e. Ix i => (i, i) -> [e] -> Array i e
Array.listArray (Array i a -> (i, i)
forall i e. Array i e -> (i, i)
Array.bounds Array i a
arr) ([b] -> Array i b) -> f [b] -> f (Array i b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((i, a) -> f b) -> [(i, a)] -> f [b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((i -> a -> f b) -> (i, a) -> f b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry i -> a -> f b
f) (Array i a -> [(i, a)]
forall i e. Ix i => Array i e -> [(i, e)]
Array.assocs Array i a
arr)
{-# INLINE itraverse #-}
instance FunctorWithIndex i f => FunctorWithIndex [i] (Cofree f) where
imap :: ([i] -> a -> b) -> Cofree f a -> Cofree f b
imap f :: [i] -> a -> b
f (a :: a
a :< as :: f (Cofree f a)
as) = [i] -> a -> b
f [] a
a b -> f (Cofree f b) -> Cofree f b
forall (f :: * -> *) a. a -> f (Cofree f a) -> Cofree f a
:< (i -> Cofree f a -> Cofree f b) -> f (Cofree f a) -> f (Cofree f b)
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (\i :: i
i -> ([i] -> a -> b) -> Cofree f a -> Cofree f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap ([i] -> a -> b
f ([i] -> a -> b) -> ([i] -> [i]) -> [i] -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) i
i)) f (Cofree f a)
as
{-# INLINE imap #-}
instance FoldableWithIndex i f => FoldableWithIndex [i] (Cofree f) where
ifoldMap :: ([i] -> a -> m) -> Cofree f a -> m
ifoldMap f :: [i] -> a -> m
f (a :: a
a :< as :: f (Cofree f a)
as) = [i] -> a -> m
f [] a
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (i -> Cofree f a -> m) -> f (Cofree f a) -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i -> ([i] -> a -> m) -> Cofree f a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap ([i] -> a -> m
f ([i] -> a -> m) -> ([i] -> [i]) -> [i] -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) i
i)) f (Cofree f a)
as
{-# INLINE ifoldMap #-}
instance TraversableWithIndex i f => TraversableWithIndex [i] (Cofree f) where
itraverse :: ([i] -> a -> f b) -> Cofree f a -> f (Cofree f b)
itraverse f :: [i] -> a -> f b
f (a :: a
a :< as :: f (Cofree f a)
as) = b -> f (Cofree f b) -> Cofree f b
forall (f :: * -> *) a. a -> f (Cofree f a) -> Cofree f a
(:<) (b -> f (Cofree f b) -> Cofree f b)
-> f b -> f (f (Cofree f b) -> Cofree f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [i] -> a -> f b
f [] a
a f (f (Cofree f b) -> Cofree f b)
-> f (f (Cofree f b)) -> f (Cofree f b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (i -> Cofree f a -> f (Cofree f b))
-> f (Cofree f a) -> f (f (Cofree f b))
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\i :: i
i -> ([i] -> a -> f b) -> Cofree f a -> f (Cofree f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse ([i] -> a -> f b
f ([i] -> a -> f b) -> ([i] -> [i]) -> [i] -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) i
i)) f (Cofree f a)
as
{-# INLINE itraverse #-}
instance (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (Compose f g) where
imap :: ((i, j) -> a -> b) -> Compose f g a -> Compose f g b
imap f :: (i, j) -> a -> b
f (Compose fg :: f (g a)
fg) = f (g b) -> Compose f g b
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (f (g b) -> Compose f g b) -> f (g b) -> Compose f g b
forall a b. (a -> b) -> a -> b
$ (i -> g a -> g b) -> f (g a) -> f (g b)
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (\k :: i
k -> (j -> a -> b) -> g a -> g b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap ((i, j) -> a -> b
f ((i, j) -> a -> b) -> (j -> (i, j)) -> j -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) i
k)) f (g a)
fg
{-# INLINE imap #-}
instance (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (Compose f g) where
ifoldMap :: ((i, j) -> a -> m) -> Compose f g a -> m
ifoldMap f :: (i, j) -> a -> m
f (Compose fg :: f (g a)
fg) = (i -> g a -> m) -> f (g a) -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\k :: i
k -> (j -> a -> m) -> g a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap ((i, j) -> a -> m
f ((i, j) -> a -> m) -> (j -> (i, j)) -> j -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) i
k)) f (g a)
fg
{-# INLINE ifoldMap #-}
instance (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (Compose f g) where
itraverse :: ((i, j) -> a -> f b) -> Compose f g a -> f (Compose f g b)
itraverse f :: (i, j) -> a -> f b
f (Compose fg :: f (g a)
fg) = f (g b) -> Compose f g b
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (f (g b) -> Compose f g b) -> f (f (g b)) -> f (Compose f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> g a -> f (g b)) -> f (g a) -> f (f (g b))
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\k :: i
k -> (j -> a -> f b) -> g a -> f (g b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse ((i, j) -> a -> f b
f ((i, j) -> a -> f b) -> (j -> (i, j)) -> j -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) i
k)) f (g a)
fg
{-# INLINE itraverse #-}
instance (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Sum f g) where
imap :: (Either i j -> a -> b) -> Sum f g a -> Sum f g b
imap q :: Either i j -> a -> b
q (InL fa :: f a
fa) = f b -> Sum f g b
forall k (f :: k -> *) (g :: k -> *) (a :: k). f a -> Sum f g a
InL ((i -> a -> b) -> f a -> f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Either i j -> a -> b
q (Either i j -> a -> b) -> (i -> Either i j) -> i -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa)
imap q :: Either i j -> a -> b
q (InR ga :: g a
ga) = g b -> Sum f g b
forall k (f :: k -> *) (g :: k -> *) (a :: k). g a -> Sum f g a
InR ((j -> a -> b) -> g a -> g b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Either i j -> a -> b
q (Either i j -> a -> b) -> (j -> Either i j) -> j -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga)
{-# INLINE imap #-}
instance (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Sum f g) where
ifoldMap :: (Either i j -> a -> m) -> Sum f g a -> m
ifoldMap q :: Either i j -> a -> m
q (InL fa :: f a
fa) = (i -> a -> m) -> f a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Either i j -> a -> m
q (Either i j -> a -> m) -> (i -> Either i j) -> i -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa
ifoldMap q :: Either i j -> a -> m
q (InR ga :: g a
ga) = (j -> a -> m) -> g a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Either i j -> a -> m
q (Either i j -> a -> m) -> (j -> Either i j) -> j -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga
{-# INLINE ifoldMap #-}
instance (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Sum f g) where
itraverse :: (Either i j -> a -> f b) -> Sum f g a -> f (Sum f g b)
itraverse q :: Either i j -> a -> f b
q (InL fa :: f a
fa) = f b -> Sum f g b
forall k (f :: k -> *) (g :: k -> *) (a :: k). f a -> Sum f g a
InL (f b -> Sum f g b) -> f (f b) -> f (Sum f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> a -> f b) -> f a -> f (f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Either i j -> a -> f b
q (Either i j -> a -> f b) -> (i -> Either i j) -> i -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa
itraverse q :: Either i j -> a -> f b
q (InR ga :: g a
ga) = g b -> Sum f g b
forall k (f :: k -> *) (g :: k -> *) (a :: k). g a -> Sum f g a
InR (g b -> Sum f g b) -> f (g b) -> f (Sum f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (j -> a -> f b) -> g a -> f (g b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Either i j -> a -> f b
q (Either i j -> a -> f b) -> (j -> Either i j) -> j -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga
{-# INLINE itraverse #-}
instance FunctorWithIndex i m => FunctorWithIndex i (IdentityT m) where
imap :: (i -> a -> b) -> IdentityT m a -> IdentityT m b
imap f :: i -> a -> b
f (IdentityT m :: m a
m) = m b -> IdentityT m b
forall k (f :: k -> *) (a :: k). f a -> IdentityT f a
IdentityT (m b -> IdentityT m b) -> m b -> IdentityT m b
forall a b. (a -> b) -> a -> b
$ (i -> a -> b) -> m a -> m b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap i -> a -> b
f m a
m
{-# INLINE imap #-}
instance FoldableWithIndex i m => FoldableWithIndex i (IdentityT m) where
ifoldMap :: (i -> a -> m) -> IdentityT m a -> m
ifoldMap f :: i -> a -> m
f (IdentityT m :: m a
m) = (i -> a -> m) -> m a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap i -> a -> m
f m a
m
{-# INLINE ifoldMap #-}
instance TraversableWithIndex i m => TraversableWithIndex i (IdentityT m) where
itraverse :: (i -> a -> f b) -> IdentityT m a -> f (IdentityT m b)
itraverse f :: i -> a -> f b
f (IdentityT m :: m a
m) = m b -> IdentityT m b
forall k (f :: k -> *) (a :: k). f a -> IdentityT f a
IdentityT (m b -> IdentityT m b) -> f (m b) -> f (IdentityT m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> a -> f b) -> m a -> f (m b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse i -> a -> f b
f m a
m
{-# INLINE itraverse #-}
instance (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Product f g) where
imap :: (Either i j -> a -> b) -> Product f g a -> Product f g b
imap f :: Either i j -> a -> b
f (Pair a :: f a
a b :: g a
b) = f b -> g b -> Product f g b
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair ((i -> a -> b) -> f a -> f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Either i j -> a -> b
f (Either i j -> a -> b) -> (i -> Either i j) -> i -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
a) ((j -> a -> b) -> g a -> g b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Either i j -> a -> b
f (Either i j -> a -> b) -> (j -> Either i j) -> j -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
b)
{-# INLINE imap #-}
instance (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Product f g) where
ifoldMap :: (Either i j -> a -> m) -> Product f g a -> m
ifoldMap f :: Either i j -> a -> m
f (Pair a :: f a
a b :: g a
b) = (i -> a -> m) -> f a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Either i j -> a -> m
f (Either i j -> a -> m) -> (i -> Either i j) -> i -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (j -> a -> m) -> g a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Either i j -> a -> m
f (Either i j -> a -> m) -> (j -> Either i j) -> j -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
b
{-# INLINE ifoldMap #-}
instance (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Product f g) where
itraverse :: (Either i j -> a -> f b) -> Product f g a -> f (Product f g b)
itraverse f :: Either i j -> a -> f b
f (Pair a :: f a
a b :: g a
b) = f b -> g b -> Product f g b
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair (f b -> g b -> Product f g b)
-> f (f b) -> f (g b -> Product f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> a -> f b) -> f a -> f (f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Either i j -> a -> f b
f (Either i j -> a -> f b) -> (i -> Either i j) -> i -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
a f (g b -> Product f g b) -> f (g b) -> f (Product f g b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (j -> a -> f b) -> g a -> f (g b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Either i j -> a -> f b
f (Either i j -> a -> f b) -> (j -> Either i j) -> j -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
b
{-# INLINE itraverse #-}
instance FunctorWithIndex i m => FunctorWithIndex (e, i) (ReaderT e m) where
imap :: ((e, i) -> a -> b) -> ReaderT e m a -> ReaderT e m b
imap f :: (e, i) -> a -> b
f (ReaderT m :: e -> m a
m) = (e -> m b) -> ReaderT e m b
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((e -> m b) -> ReaderT e m b) -> (e -> m b) -> ReaderT e m b
forall a b. (a -> b) -> a -> b
$ \k :: e
k -> (i -> a -> b) -> m a -> m b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap ((e, i) -> a -> b
f ((e, i) -> a -> b) -> (i -> (e, i)) -> i -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) e
k) (e -> m a
m e
k)
{-# INLINE imap #-}
instance FunctorWithIndex i w => FunctorWithIndex (s, i) (TracedT s w) where
imap :: ((s, i) -> a -> b) -> TracedT s w a -> TracedT s w b
imap f :: (s, i) -> a -> b
f (TracedT w :: w (s -> a)
w) = w (s -> b) -> TracedT s w b
forall m (w :: * -> *) a. w (m -> a) -> TracedT m w a
TracedT (w (s -> b) -> TracedT s w b) -> w (s -> b) -> TracedT s w b
forall a b. (a -> b) -> a -> b
$ (i -> (s -> a) -> s -> b) -> w (s -> a) -> w (s -> b)
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (\k' :: i
k' g :: s -> a
g k :: s
k -> (s, i) -> a -> b
f (s
k, i
k') (s -> a
g s
k)) w (s -> a)
w
{-# INLINE imap #-}
instance FunctorWithIndex [Int] Tree where
imap :: ([Int] -> a -> b) -> Tree a -> Tree b
imap f :: [Int] -> a -> b
f (Node a :: a
a as :: Forest a
as) = b -> Forest b -> Tree b
forall a. a -> Forest a -> Tree a
Node ([Int] -> a -> b
f [] a
a) (Forest b -> Tree b) -> Forest b -> Tree b
forall a b. (a -> b) -> a -> b
$ (Int -> Tree a -> Tree b) -> Forest a -> Forest b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (\i :: Int
i -> ([Int] -> a -> b) -> Tree a -> Tree b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap ([Int] -> a -> b
f ([Int] -> a -> b) -> ([Int] -> [Int]) -> [Int] -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) Int
i)) Forest a
as
{-# INLINE imap #-}
instance FoldableWithIndex [Int] Tree where
ifoldMap :: ([Int] -> a -> m) -> Tree a -> m
ifoldMap f :: [Int] -> a -> m
f (Node a :: a
a as :: Forest a
as) = [Int] -> a -> m
f [] a
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (Int -> Tree a -> m) -> Forest a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: Int
i -> ([Int] -> a -> m) -> Tree a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap ([Int] -> a -> m
f ([Int] -> a -> m) -> ([Int] -> [Int]) -> [Int] -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) Int
i)) Forest a
as
{-# INLINE ifoldMap #-}
instance TraversableWithIndex [Int] Tree where
itraverse :: ([Int] -> a -> f b) -> Tree a -> f (Tree b)
itraverse f :: [Int] -> a -> f b
f (Node a :: a
a as :: Forest a
as) = b -> Forest b -> Tree b
forall a. a -> Forest a -> Tree a
Node (b -> Forest b -> Tree b) -> f b -> f (Forest b -> Tree b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int] -> a -> f b
f [] a
a f (Forest b -> Tree b) -> f (Forest b) -> f (Tree b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Int -> Tree a -> f (Tree b)) -> Forest a -> f (Forest b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\i :: Int
i -> ([Int] -> a -> f b) -> Tree a -> f (Tree b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse ([Int] -> a -> f b
f ([Int] -> a -> f b) -> ([Int] -> [Int]) -> [Int] -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) Int
i)) Forest a
as
{-# INLINE itraverse #-}
instance FunctorWithIndex Void Proxy where
imap :: (Void -> a -> b) -> Proxy a -> Proxy b
imap _ Proxy = Proxy b
forall k (t :: k). Proxy t
Proxy
{-# INLINE imap #-}
instance FoldableWithIndex Void Proxy where
ifoldMap :: (Void -> a -> m) -> Proxy a -> m
ifoldMap _ _ = m
forall a. Monoid a => a
mempty
{-# INLINE ifoldMap #-}
instance TraversableWithIndex Void Proxy where
itraverse :: (Void -> a -> f b) -> Proxy a -> f (Proxy b)
itraverse _ _ = Proxy b -> f (Proxy b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Proxy b
forall k (t :: k). Proxy t
Proxy
{-# INLINE itraverse #-}
instance FunctorWithIndex () (Tagged a) where
imap :: (() -> a -> b) -> Tagged a a -> Tagged a b
imap f :: () -> a -> b
f (Tagged a :: a
a) = b -> Tagged a b
forall k (s :: k) b. b -> Tagged s b
Tagged (() -> a -> b
f () a
a)
{-# INLINE imap #-}
instance FoldableWithIndex () (Tagged a) where
ifoldMap :: (() -> a -> m) -> Tagged a a -> m
ifoldMap f :: () -> a -> m
f (Tagged a :: a
a) = () -> a -> m
f () a
a
{-# INLINE ifoldMap #-}
instance TraversableWithIndex () (Tagged a) where
itraverse :: (() -> a -> f b) -> Tagged a a -> f (Tagged a b)
itraverse f :: () -> a -> f b
f (Tagged a :: a
a) = b -> Tagged a b
forall k (s :: k) b. b -> Tagged s b
Tagged (b -> Tagged a b) -> f b -> f (Tagged a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> () -> a -> f b
f () a
a
{-# INLINE itraverse #-}
instance FunctorWithIndex Void V1 where
imap :: (Void -> a -> b) -> V1 a -> V1 b
imap _ v :: V1 a
v = V1 a
v V1 a -> V1 b -> V1 b
forall a b. a -> b -> b
`seq` V1 b
forall a. HasCallStack => a
undefined
{-# INLINE imap #-}
instance FoldableWithIndex Void V1 where
ifoldMap :: (Void -> a -> m) -> V1 a -> m
ifoldMap _ v :: V1 a
v = V1 a
v V1 a -> m -> m
forall a b. a -> b -> b
`seq` m
forall a. HasCallStack => a
undefined
instance TraversableWithIndex Void V1 where
itraverse :: (Void -> a -> f b) -> V1 a -> f (V1 b)
itraverse _ v :: V1 a
v = V1 a
v V1 a -> f (V1 b) -> f (V1 b)
forall a b. a -> b -> b
`seq` f (V1 b)
forall a. HasCallStack => a
undefined
instance FunctorWithIndex Void U1 where
imap :: (Void -> a -> b) -> U1 a -> U1 b
imap _ U1 = U1 b
forall k (p :: k). U1 p
U1
{-# INLINE imap #-}
instance FoldableWithIndex Void U1 where
ifoldMap :: (Void -> a -> m) -> U1 a -> m
ifoldMap _ _ = m
forall a. Monoid a => a
mempty
{-# INLINE ifoldMap #-}
instance TraversableWithIndex Void U1 where
itraverse :: (Void -> a -> f b) -> U1 a -> f (U1 b)
itraverse _ U1 = U1 b -> f (U1 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 b
forall k (p :: k). U1 p
U1
{-# INLINE itraverse #-}
instance FunctorWithIndex () Par1 where
imap :: (() -> a -> b) -> Par1 a -> Par1 b
imap f :: () -> a -> b
f = (a -> b) -> Par1 a -> Par1 b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (() -> a -> b
f ())
{-# INLINE imap #-}
instance FoldableWithIndex () Par1 where
ifoldMap :: (() -> a -> m) -> Par1 a -> m
ifoldMap f :: () -> a -> m
f (Par1 a :: a
a) = () -> a -> m
f () a
a
{-# INLINE ifoldMap #-}
instance TraversableWithIndex () Par1 where
itraverse :: (() -> a -> f b) -> Par1 a -> f (Par1 b)
itraverse f :: () -> a -> f b
f (Par1 a :: a
a) = b -> Par1 b
forall p. p -> Par1 p
Par1 (b -> Par1 b) -> f b -> f (Par1 b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> () -> a -> f b
f () a
a
{-# INLINE itraverse #-}
instance (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (f :.: g) where
imap :: ((i, j) -> a -> b) -> (:.:) f g a -> (:.:) f g b
imap q :: (i, j) -> a -> b
q (Comp1 fga :: f (g a)
fga) = f (g b) -> (:.:) f g b
forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 ((i -> g a -> g b) -> f (g a) -> f (g b)
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (\k :: i
k -> (j -> a -> b) -> g a -> g b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap ((i, j) -> a -> b
q ((i, j) -> a -> b) -> (j -> (i, j)) -> j -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) i
k)) f (g a)
fga)
{-# INLINE imap #-}
instance (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (f :.: g) where
ifoldMap :: ((i, j) -> a -> m) -> (:.:) f g a -> m
ifoldMap q :: (i, j) -> a -> m
q (Comp1 fga :: f (g a)
fga) = (i -> g a -> m) -> f (g a) -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\k :: i
k -> (j -> a -> m) -> g a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap ((i, j) -> a -> m
q ((i, j) -> a -> m) -> (j -> (i, j)) -> j -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) i
k)) f (g a)
fga
{-# INLINE ifoldMap #-}
instance (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (f :.: g) where
itraverse :: ((i, j) -> a -> f b) -> (:.:) f g a -> f ((:.:) f g b)
itraverse q :: (i, j) -> a -> f b
q (Comp1 fga :: f (g a)
fga) = f (g b) -> (:.:) f g b
forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 (f (g b) -> (:.:) f g b) -> f (f (g b)) -> f ((:.:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> g a -> f (g b)) -> f (g a) -> f (f (g b))
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\k :: i
k -> (j -> a -> f b) -> g a -> f (g b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse ((i, j) -> a -> f b
q ((i, j) -> a -> f b) -> (j -> (i, j)) -> j -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) i
k)) f (g a)
fga
{-# INLINE itraverse #-}
instance (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :*: g) where
imap :: (Either i j -> a -> b) -> (:*:) f g a -> (:*:) f g b
imap q :: Either i j -> a -> b
q (fa :: f a
fa :*: ga :: g a
ga) = (i -> a -> b) -> f a -> f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Either i j -> a -> b
q (Either i j -> a -> b) -> (i -> Either i j) -> i -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa f b -> g b -> (:*:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: (j -> a -> b) -> g a -> g b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Either i j -> a -> b
q (Either i j -> a -> b) -> (j -> Either i j) -> j -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga
{-# INLINE imap #-}
instance (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :*: g) where
ifoldMap :: (Either i j -> a -> m) -> (:*:) f g a -> m
ifoldMap q :: Either i j -> a -> m
q (fa :: f a
fa :*: ga :: g a
ga) = (i -> a -> m) -> f a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Either i j -> a -> m
q (Either i j -> a -> m) -> (i -> Either i j) -> i -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (j -> a -> m) -> g a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Either i j -> a -> m
q (Either i j -> a -> m) -> (j -> Either i j) -> j -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga
{-# INLINE ifoldMap #-}
instance (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :*: g) where
itraverse :: (Either i j -> a -> f b) -> (:*:) f g a -> f ((:*:) f g b)
itraverse q :: Either i j -> a -> f b
q (fa :: f a
fa :*: ga :: g a
ga) = 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) -> f (f b) -> f (g b -> (:*:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> a -> f b) -> f a -> f (f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Either i j -> a -> f b
q (Either i j -> a -> f b) -> (i -> Either i j) -> i -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa f (g b -> (:*:) f g b) -> f (g b) -> f ((:*:) f g b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (j -> a -> f b) -> g a -> f (g b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Either i j -> a -> f b
q (Either i j -> a -> f b) -> (j -> Either i j) -> j -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga
{-# INLINE itraverse #-}
instance (FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :+: g) where
imap :: (Either i j -> a -> b) -> (:+:) f g a -> (:+:) f g b
imap q :: Either i j -> a -> b
q (L1 fa :: f a
fa) = f b -> (:+:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 ((i -> a -> b) -> f a -> f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Either i j -> a -> b
q (Either i j -> a -> b) -> (i -> Either i j) -> i -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa)
imap q :: Either i j -> a -> b
q (R1 ga :: g a
ga) = g b -> (:+:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 ((j -> a -> b) -> g a -> g b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Either i j -> a -> b
q (Either i j -> a -> b) -> (j -> Either i j) -> j -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga)
{-# INLINE imap #-}
instance (FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :+: g) where
ifoldMap :: (Either i j -> a -> m) -> (:+:) f g a -> m
ifoldMap q :: Either i j -> a -> m
q (L1 fa :: f a
fa) = (i -> a -> m) -> f a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Either i j -> a -> m
q (Either i j -> a -> m) -> (i -> Either i j) -> i -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa
ifoldMap q :: Either i j -> a -> m
q (R1 ga :: g a
ga) = (j -> a -> m) -> g a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Either i j -> a -> m
q (Either i j -> a -> m) -> (j -> Either i j) -> j -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga
{-# INLINE ifoldMap #-}
instance (TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :+: g) where
itraverse :: (Either i j -> a -> f b) -> (:+:) f g a -> f ((:+:) f g b)
itraverse q :: Either i j -> a -> f b
q (L1 fa :: f a
fa) = f b -> (:+:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (f b -> (:+:) f g b) -> f (f b) -> f ((:+:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> a -> f b) -> f a -> f (f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Either i j -> a -> f b
q (Either i j -> a -> f b) -> (i -> Either i j) -> i -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Either i j
forall a b. a -> Either a b
Left) f a
fa
itraverse q :: Either i j -> a -> f b
q (R1 ga :: g a
ga) = g b -> (:+:) f g b
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (g b -> (:+:) f g b) -> f (g b) -> f ((:+:) f g b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (j -> a -> f b) -> g a -> f (g b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Either i j -> a -> f b
q (Either i j -> a -> f b) -> (j -> Either i j) -> j -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. j -> Either i j
forall a b. b -> Either a b
Right) g a
ga
{-# INLINE itraverse #-}
instance FunctorWithIndex i f => FunctorWithIndex i (Rec1 f) where
imap :: (i -> a -> b) -> Rec1 f a -> Rec1 f b
imap q :: i -> a -> b
q (Rec1 f :: f a
f) = f b -> Rec1 f b
forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
Rec1 ((i -> a -> b) -> f a -> f b
forall i (f :: * -> *) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap i -> a -> b
q f a
f)
{-# INLINE imap #-}
instance FoldableWithIndex i f => FoldableWithIndex i (Rec1 f) where
ifoldMap :: (i -> a -> m) -> Rec1 f a -> m
ifoldMap q :: i -> a -> m
q (Rec1 f :: f a
f) = (i -> a -> m) -> f a -> m
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap i -> a -> m
q f a
f
{-# INLINE ifoldMap #-}
instance TraversableWithIndex i f => TraversableWithIndex i (Rec1 f) where
itraverse :: (i -> a -> f b) -> Rec1 f a -> f (Rec1 f b)
itraverse q :: i -> a -> f b
q (Rec1 f :: f a
f) = f b -> Rec1 f b
forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
Rec1 (f b -> Rec1 f b) -> f (f b) -> f (Rec1 f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (i -> a -> f b) -> f a -> f (f b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse i -> a -> f b
q f a
f
{-# INLINE itraverse #-}
instance FunctorWithIndex Void (K1 i c) where
imap :: (Void -> a -> b) -> K1 i c a -> K1 i c b
imap _ (K1 c :: c
c) = c -> K1 i c b
forall k i c (p :: k). c -> K1 i c p
K1 c
c
{-# INLINE imap #-}
instance FoldableWithIndex Void (K1 i c) where
ifoldMap :: (Void -> a -> m) -> K1 i c a -> m
ifoldMap _ _ = m
forall a. Monoid a => a
mempty
{-# INLINE ifoldMap #-}
instance TraversableWithIndex Void (K1 i c) where
itraverse :: (Void -> a -> f b) -> K1 i c a -> f (K1 i c b)
itraverse _ (K1 a :: c
a) = K1 i c b -> f (K1 i c b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (c -> K1 i c b
forall k i c (p :: k). c -> K1 i c p
K1 c
a)
{-# INLINE itraverse #-}
skip :: a -> ()
skip :: a -> ()
skip _ = ()
{-# INLINE skip #-}
ifoldMapBy :: FoldableWithIndex i t => (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r
ifoldMapBy :: (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r
ifoldMapBy f :: r -> r -> r
f z :: r
z g :: i -> a -> r
g = (r -> r -> r)
-> r
-> (forall s.
Reifies s (ReifiedMonoid r) =>
t a -> ReflectedMonoid r s)
-> t a
-> r
forall a t.
(a -> a -> a)
-> a
-> (forall s.
Reifies s (ReifiedMonoid a) =>
t -> ReflectedMonoid a s)
-> t
-> a
reifyMonoid r -> r -> r
f r
z ((i -> a -> ReflectedMonoid r s) -> t a -> ReflectedMonoid r s
forall i (f :: * -> *) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (\i :: i
i a :: a
a -> r -> ReflectedMonoid r s
forall k a (s :: k). a -> ReflectedMonoid a s
ReflectedMonoid (i -> a -> r
g i
i a
a)))
ifoldMapByOf :: IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r
ifoldMapByOf :: IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r
ifoldMapByOf l :: IndexedFold i t a
l f :: r -> r -> r
f z :: r
z g :: i -> a -> r
g = (r -> r -> r)
-> r
-> (forall s.
Reifies s (ReifiedMonoid r) =>
t -> ReflectedMonoid r s)
-> t
-> r
forall a t.
(a -> a -> a)
-> a
-> (forall s.
Reifies s (ReifiedMonoid a) =>
t -> ReflectedMonoid a s)
-> t
-> a
reifyMonoid r -> r -> r
f r
z (IndexedGetting i (ReflectedMonoid r s) t a
-> (i -> a -> ReflectedMonoid r s) -> t -> ReflectedMonoid r s
forall i m s a. IndexedGetting i m s a -> (i -> a -> m) -> s -> m
ifoldMapOf IndexedGetting i (ReflectedMonoid r s) t a
IndexedFold i t a
l (\i :: i
i a :: a
a -> r -> ReflectedMonoid r s
forall k a (s :: k). a -> ReflectedMonoid a s
ReflectedMonoid (i -> a -> r
g i
i a
a)))
itraverseBy :: TraversableWithIndex i t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> t a -> f (t b)
itraverseBy :: (forall x. x -> f x)
-> (forall x y. f (x -> y) -> f x -> f y)
-> (i -> a -> f b)
-> t a
-> f (t b)
itraverseBy pur :: forall x. x -> f x
pur app :: forall x y. f (x -> y) -> f x -> f y
app f :: i -> a -> f b
f = (forall x. x -> f x)
-> (forall x y. f (x -> y) -> f x -> f y)
-> (forall s.
Reifies s (ReifiedApplicative f) =>
t a -> ReflectedApplicative f s (t b))
-> t a
-> f (t b)
forall (f :: * -> *) t a.
(forall x. x -> f x)
-> (forall x y. f (x -> y) -> f x -> f y)
-> (forall s.
Reifies s (ReifiedApplicative f) =>
t -> ReflectedApplicative f s a)
-> t
-> f a
reifyApplicative forall x. x -> f x
pur forall x y. f (x -> y) -> f x -> f y
app ((i -> a -> ReflectedApplicative f s b)
-> t a -> ReflectedApplicative f s (t b)
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (\i :: i
i a :: a
a -> f b -> ReflectedApplicative f s b
forall k k1 (f :: k -> *) (s :: k1) (a :: k).
f a -> ReflectedApplicative f s a
ReflectedApplicative (i -> a -> f b
f i
i a
a)))
itraverseByOf :: IndexedTraversal i s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> s -> f t
itraverseByOf :: IndexedTraversal i s t a b
-> (forall x. x -> f x)
-> (forall x y. f (x -> y) -> f x -> f y)
-> (i -> a -> f b)
-> s
-> f t
itraverseByOf l :: IndexedTraversal i s t a b
l pur :: forall x. x -> f x
pur app :: forall x y. f (x -> y) -> f x -> f y
app f :: i -> a -> f b
f = (forall x. x -> f x)
-> (forall x y. f (x -> y) -> f x -> f y)
-> (forall s.
Reifies s (ReifiedApplicative f) =>
s -> ReflectedApplicative f s t)
-> s
-> f t
forall (f :: * -> *) t a.
(forall x. x -> f x)
-> (forall x y. f (x -> y) -> f x -> f y)
-> (forall s.
Reifies s (ReifiedApplicative f) =>
t -> ReflectedApplicative f s a)
-> t
-> f a
reifyApplicative forall x. x -> f x
pur forall x y. f (x -> y) -> f x -> f y
app ((Indexed i a (ReflectedApplicative f s b)
-> s -> ReflectedApplicative f s t)
-> (i -> a -> ReflectedApplicative f s b)
-> s
-> ReflectedApplicative f s t
forall i a (f :: * -> *) b s t.
(Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t
itraverseOf Indexed i a (ReflectedApplicative f s b)
-> s -> ReflectedApplicative f s t
IndexedTraversal i s t a b
l (\i :: i
i a :: a
a -> f b -> ReflectedApplicative f s b
forall k k1 (f :: k -> *) (s :: k1) (a :: k).
f a -> ReflectedApplicative f s a
ReflectedApplicative (i -> a -> f b
f i
i a
a)))