{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
#ifdef TRUSTWORTHY
{-# LANGUAGE Trustworthy #-}
#endif
#include "lens-common.h"
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 Prelude ()
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.Prelude
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.Constant (Constant (..))
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.Map as Map
import Data.Monoid hiding (Sum, Product)
import Data.Reflection
import Data.Sequence hiding ((:<), index)
import Data.Tree
import Data.Tuple (swap)
import Data.Vector (Vector)
import qualified Data.Vector as V
import GHC.Generics
#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
(<.) Indexed i s t -> r
f (a -> b) -> s -> t
g 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 p a fb
f 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 i -> j
ij Indexed i a b -> r
f 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
Indexed i s t -> r
f <.> :: (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> p a b -> r
<.> 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 i -> j -> p
ijk Indexed i s t -> r
istr Indexed j a b -> s -> t
jabst 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 -> 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 -> 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 i -> Bool
p 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 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 i
j 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 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
$ \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 -> 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 i -> a -> b -> b
f b
z 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 -> (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 i -> b -> a -> b
f b
z f a
t = Endo b -> b -> b
forall a. Endo a -> a -> a
appEndo (Dual (Endo b) -> Endo b
forall a. Dual a -> a
getDual ((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 -> 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' i -> a -> b -> b
f b
z0 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 b -> b
k a
x 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' i -> b -> a -> b
f b
z0 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 a
x b -> b
k 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 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 -> 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 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 -> 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 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 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_ 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 -> 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_ 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 -> 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 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 a
a 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 i -> a -> b -> m b
f b
z0 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 b -> m b
k a
x 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 i -> b -> a -> m b
f b
z0 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 a
x b -> m b
k 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 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 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 -> 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 i -> s -> a -> (s, b)
f s
s0 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 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, 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 i -> s -> a -> (s, b)
f s
s0 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 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, 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 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 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 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 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 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 -> 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 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 -> 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 () -> a -> b
f (Identity 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 () -> a -> m
f (Identity a
a) = () -> a -> m
f () a
a
{-# INLINE ifoldMap #-}
instance TraversableWithIndex () Identity where
itraverse :: (() -> a -> f b) -> Identity a -> f (Identity b)
itraverse () -> a -> f b
f (Identity 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 Void (Const e) where
imap :: (Void -> a -> b) -> Const e a -> Const e b
imap Void -> a -> b
_ (Const e
a) = e -> Const e b
forall k a (b :: k). a -> Const a b
Const e
a
{-# INLINE imap #-}
instance FoldableWithIndex Void (Const e) where
ifoldMap :: (Void -> a -> m) -> Const e a -> m
ifoldMap Void -> a -> m
_ Const e a
_ = m
forall a. Monoid a => a
mempty
{-# INLINE ifoldMap #-}
instance TraversableWithIndex Void (Const e) where
itraverse :: (Void -> a -> f b) -> Const e a -> f (Const e b)
itraverse Void -> a -> f b
_ (Const e
a) = Const e b -> f (Const e b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> Const e b
forall k a (b :: k). a -> Const a b
Const e
a)
{-# INLINE itraverse #-}
instance FunctorWithIndex Void (Constant e) where
imap :: (Void -> a -> b) -> Constant e a -> Constant e b
imap Void -> a -> b
_ (Constant e
a) = e -> Constant e b
forall k a (b :: k). a -> Constant a b
Constant e
a
{-# INLINE imap #-}
instance FoldableWithIndex Void (Constant e) where
ifoldMap :: (Void -> a -> m) -> Constant e a -> m
ifoldMap Void -> a -> m
_ Constant e a
_ = m
forall a. Monoid a => a
mempty
{-# INLINE ifoldMap #-}
instance TraversableWithIndex Void (Constant e) where
itraverse :: (Void -> a -> f b) -> Constant e a -> f (Constant e b)
itraverse Void -> a -> f b
_ (Constant e
a) = Constant e b -> f (Constant e b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> Constant e b
forall k a (b :: k). a -> Constant a b
Constant e
a)
{-# INLINE itraverse #-}
instance FunctorWithIndex k ((,) k) where
imap :: (k -> a -> b) -> (k, a) -> (k, b)
imap k -> a -> b
f (k
k,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 k -> a -> f b
f (k
k, 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 () -> 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 () -> 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 () -> 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 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 r -> a -> b
f r -> a
g 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 i -> a -> b
f = Level i a -> Level i b
go where
go :: Level i a -> Level i b
go (Two Word
n Level i a
l 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 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 Level i a
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 i -> a -> m
f = Level i a -> m
go where
go :: Level i a -> m
go (Two Word
_ Level i a
l 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 a
a) = i -> a -> m
f i
i a
a
go Level i a
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 i -> a -> f b
f = Level i a -> f (Level i b)
go where
go :: Level i a -> f (Level i b)
go (Two Word
n Level i a
l 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 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 Level i a
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 i -> a -> b
f (MagmaAp Magma i (x -> t) b a
x 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 i -> a -> b
_ (MagmaPure t
x) = t -> Magma i t b b
forall x i b a. x -> Magma i x b a
MagmaPure t
x
imap i -> a -> b
f (MagmaFmap x -> t
xy 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 i -> a -> b
f (Magma i
i 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 i -> a -> m
f (MagmaAp Magma i (x -> t) b a
x 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 i -> a -> m
_ MagmaPure{} = m
forall a. Monoid a => a
mempty
ifoldMap i -> a -> m
f (MagmaFmap x -> t
_ 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 i -> a -> m
f (Magma i
i 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 i -> a -> f b
f (MagmaAp Magma i (x -> t) b a
x 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 i -> a -> f b
_ (MagmaPure 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 i -> a -> f b
f (MagmaFmap x -> t
xy 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 i -> a -> f b
f (Magma i
i 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 [i] -> a -> b
f (Pure 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 [i] -> a -> b
f (Free 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] -> 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 [i] -> a -> m
f (Pure a
a) = [i] -> a -> m
f [] a
a
ifoldMap [i] -> a -> m
f (Free 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] -> 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 [i] -> a -> f b
f (Pure 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 [i] -> a -> f b
f (Free 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] -> 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 i -> a -> b
f 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 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 i -> a -> f b
f 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 [i] -> a -> b
f (a
a :< 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] -> 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 [i] -> a -> m
f (a
a :< 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] -> 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 [i] -> a -> f b
f (a
a :< 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] -> 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 (i, j) -> a -> b
f (Compose 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 (\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 (i, j) -> a -> m
f (Compose 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 (\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 (i, j) -> a -> f b
f (Compose 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 (\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 Either i j -> a -> b
q (InL 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 Either i j -> a -> b
q (InR 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 Either i j -> a -> m
q (InL 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 Either i j -> a -> m
q (InR 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 Either i j -> a -> f b
q (InL 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 Either i j -> a -> f b
q (InR 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 i -> a -> b
f (IdentityT 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 i -> a -> m
f (IdentityT 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 i -> a -> f b
f (IdentityT 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 Either i j -> a -> b
f (Pair f a
a 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 Either i j -> a -> m
f (Pair f a
a 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 Either i j -> a -> f b
f (Pair f a
a 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 (e, i) -> a -> b
f (ReaderT 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
$ \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 (s, i) -> a -> b
f (TracedT 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 (\i
k' s -> a
g 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 [Int] -> a -> b
f (Node a
a 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 (\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 [Int] -> a -> m
f (Node a
a 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 (\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 [Int] -> a -> f b
f (Node a
a 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 (\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 Void -> a -> b
_ Proxy a
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 Void -> a -> m
_ Proxy a
_ = 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 Void -> a -> f b
_ Proxy a
_ = 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 () -> a -> b
f (Tagged 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 () -> a -> m
f (Tagged 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 () -> a -> f b
f (Tagged 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 Void -> a -> b
_ V1 a
v = V1 a
v V1 a -> V1 b -> V1 b
`seq` V1 b
forall a. HasCallStack => a
undefined
{-# INLINE imap #-}
instance FoldableWithIndex Void V1 where
ifoldMap :: (Void -> a -> m) -> V1 a -> m
ifoldMap Void -> a -> m
_ V1 a
v = V1 a
v V1 a -> m -> m
`seq` m
forall a. HasCallStack => a
undefined
instance TraversableWithIndex Void V1 where
itraverse :: (Void -> a -> f b) -> V1 a -> f (V1 b)
itraverse Void -> a -> f b
_ V1 a
v = V1 a
v V1 a -> f (V1 b) -> f (V1 b)
`seq` f (V1 b)
forall a. HasCallStack => a
undefined
instance FunctorWithIndex Void U1 where
imap :: (Void -> a -> b) -> U1 a -> U1 b
imap Void -> a -> b
_ U1 a
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 Void -> a -> m
_ U1 a
_ = 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 Void -> a -> f b
_ U1 a
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 () -> 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 () -> a -> m
f (Par1 a
a) = () -> a -> m
f () a
a
{-# INLINE ifoldMap #-}
instance TraversableWithIndex () Par1 where
itraverse :: (() -> a -> f b) -> Par1 a -> f (Par1 b)
itraverse () -> a -> f b
f (Par1 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 (i, j) -> a -> b
q (Comp1 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 (\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 (i, j) -> a -> m
q (Comp1 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 (\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 (i, j) -> a -> f b
q (Comp1 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 (\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 Either i j -> a -> b
q (f a
fa :*: 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 Either i j -> a -> m
q (f a
fa :*: 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 Either i j -> a -> f b
q (f a
fa :*: 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 Either i j -> a -> b
q (L1 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 Either i j -> a -> b
q (R1 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 Either i j -> a -> m
q (L1 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 Either i j -> a -> m
q (R1 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 Either i j -> a -> f b
q (L1 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 Either i j -> a -> f b
q (R1 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 i -> a -> b
q (Rec1 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 i -> a -> m
q (Rec1 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 i -> a -> f b
q (Rec1 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 Void -> a -> b
_ (K1 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 Void -> a -> m
_ K1 i c a
_ = 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 Void -> a -> f b
_ (K1 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 a
_ = ()
{-# 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 r -> r -> r
f r
z 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 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 IndexedFold i t a
l r -> r -> r
f r
z 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 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 forall x. x -> f x
pur forall x y. f (x -> y) -> f x -> f y
app 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 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 IndexedTraversal i s t a b
l forall x. x -> f x
pur forall x y. f (x -> y) -> f x -> f y
app 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 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)))