{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
#ifdef TRUSTWORTHY
{-# LANGUAGE Trustworthy #-}
#endif

#include "lens-common.h"

-----------------------------------------------------------------------------
-- |
-- Module      :  Control.Lens.Each
-- Copyright   :  (C) 2012-16 Edward Kmett
-- License     :  BSD-style (see the file LICENSE)
-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
-- Stability   :  experimental
-- Portability :  non-portable
--
-----------------------------------------------------------------------------
module Control.Lens.Each
  (
  -- * Each
    Each(..)
  ) where

import Prelude ()

import Control.Lens.Traversal
import Control.Lens.Internal.ByteString
import Control.Lens.Internal.Prelude
import Data.Array.Unboxed as Unboxed
import Data.Array.IArray as IArray
import qualified Data.ByteString as StrictB
import qualified Data.ByteString.Lazy as LazyB
import Data.Complex
import Data.HashMap.Lazy (HashMap)
import Data.IntMap (IntMap)
import Data.Map (Map)
import Data.Sequence (Seq)
import Data.Text.Lens (text)
import qualified Data.Text as StrictT
import qualified Data.Text.Lazy as LazyT
import Data.Tree as Tree
import Data.Vector.Generic.Lens (vectorTraverse)
import qualified Data.Vector as Vector
import qualified Data.Vector.Primitive as Prim
import Data.Vector.Primitive (Prim)
import qualified Data.Vector.Storable as Storable
import Data.Vector.Storable (Storable)
import qualified Data.Vector.Unboxed as Unboxed
import Data.Vector.Unboxed (Unbox)
import Data.Word
import qualified Data.Strict as S
import Data.These (These (..))

-- $setup
-- >>> :set -XNoOverloadedStrings
-- >>> import Control.Lens
-- >>> import Data.Text.Strict.Lens as Text
-- >>> import Data.Char as Char

-- | Extract 'each' element of a (potentially monomorphic) container.
--
-- Notably, when applied to a tuple, this generalizes 'Control.Lens.Traversal.both' to arbitrary homogeneous tuples.
--
-- >>> (1,2,3) & each *~ 10
-- (10,20,30)
--
-- It can also be used on monomorphic containers like 'StrictT.Text' or 'StrictB.ByteString'.
--
-- >>> over each Char.toUpper ("hello"^.Text.packed)
-- "HELLO"
--
-- >>> ("hello","world") & each.each %~ Char.toUpper
-- ("HELLO","WORLD")
class Each s t a b | s -> a, t -> b, s b -> t, t a -> s where
  each :: Traversal s t a b
  default each :: (Traversable g, s ~ g a, t ~ g b) => Traversal s t a b
  each = (a -> f b) -> s -> f t
(a -> f b) -> g a -> f (g b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> g a -> f (g b)
traverse
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (a,a) (b,b) a b@
instance (a~a', b~b') => Each (a,a') (b,b') a b where
  each :: Traversal (a, a') (b, b') a b
each a -> f b
f ~(a
a,a'
b) = (,) (b -> b' -> (b, b')) -> f b -> f (b' -> (b, b'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b' -> (b, b')) -> f b' -> f (b, b')
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a'
b
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (a,a,a) (b,b,b) a b@
instance (a~a2, a~a3, b~b2, b~b3) => Each (a,a2,a3) (b,b2,b3) a b where
  each :: Traversal (a, a2, a3) (b, b2, b3) a b
each a -> f b
f ~(a
a,a2
b,a3
c) = (,,) (b -> b2 -> b3 -> (b, b2, b3))
-> f b -> f (b2 -> b3 -> (b, b2, b3))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b2 -> b3 -> (b, b2, b3)) -> f b2 -> f (b3 -> (b, b2, b3))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a2
b f (b3 -> (b, b2, b3)) -> f b3 -> f (b, b2, b3)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a3
c
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (a,a,a,a) (b,b,b,b) a b@
instance (a~a2, a~a3, a~a4, b~b2, b~b3, b~b4) => Each (a,a2,a3,a4) (b,b2,b3,b4) a b where
  each :: Traversal (a, a2, a3, a4) (b, b2, b3, b4) a b
each a -> f b
f ~(a
a,a2
b,a3
c,a4
d) = (,,,) (b -> b2 -> b3 -> b4 -> (b, b2, b3, b4))
-> f b -> f (b2 -> b3 -> b4 -> (b, b2, b3, b4))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b2 -> b3 -> b4 -> (b, b2, b3, b4))
-> f b2 -> f (b3 -> b4 -> (b, b2, b3, b4))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a2
b f (b3 -> b4 -> (b, b2, b3, b4))
-> f b3 -> f (b4 -> (b, b2, b3, b4))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a3
c f (b4 -> (b, b2, b3, b4)) -> f b4 -> f (b, b2, b3, b4)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a4
d
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (a,a,a,a,a) (b,b,b,b,b) a b@
instance (a~a2, a~a3, a~a4, a~a5, b~b2, b~b3, b~b4, b~b5) => Each (a,a2,a3,a4,a5) (b,b2,b3,b4,b5) a b where
  each :: Traversal (a, a2, a3, a4, a5) (b, b2, b3, b4, b5) a b
each a -> f b
f ~(a
a,a2
b,a3
c,a4
d,a5
e) = (,,,,) (b -> b2 -> b3 -> b4 -> b5 -> (b, b2, b3, b4, b5))
-> f b -> f (b2 -> b3 -> b4 -> b5 -> (b, b2, b3, b4, b5))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b2 -> b3 -> b4 -> b5 -> (b, b2, b3, b4, b5))
-> f b2 -> f (b3 -> b4 -> b5 -> (b, b2, b3, b4, b5))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a2
b f (b3 -> b4 -> b5 -> (b, b2, b3, b4, b5))
-> f b3 -> f (b4 -> b5 -> (b, b2, b3, b4, b5))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a3
c f (b4 -> b5 -> (b, b2, b3, b4, b5))
-> f b4 -> f (b5 -> (b, b2, b3, b4, b5))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a4
d f (b5 -> (b, b2, b3, b4, b5)) -> f b5 -> f (b, b2, b3, b4, b5)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a5
e
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (a,a,a,a,a,a) (b,b,b,b,b,b) a b@
instance (a~a2, a~a3, a~a4, a~a5, a~a6, b~b2, b~b3, b~b4, b~b5, b~b6) => Each (a,a2,a3,a4,a5,a6) (b,b2,b3,b4,b5,b6) a b where
  each :: Traversal (a, a2, a3, a4, a5, a6) (b, b2, b3, b4, b5, b6) a b
each a -> f b
f ~(a
a,a2
b,a3
c,a4
d,a5
e,a6
g) = (,,,,,) (b -> b2 -> b3 -> b4 -> b5 -> b6 -> (b, b2, b3, b4, b5, b6))
-> f b -> f (b2 -> b3 -> b4 -> b5 -> b6 -> (b, b2, b3, b4, b5, b6))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b2 -> b3 -> b4 -> b5 -> b6 -> (b, b2, b3, b4, b5, b6))
-> f b2 -> f (b3 -> b4 -> b5 -> b6 -> (b, b2, b3, b4, b5, b6))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a2
b f (b3 -> b4 -> b5 -> b6 -> (b, b2, b3, b4, b5, b6))
-> f b3 -> f (b4 -> b5 -> b6 -> (b, b2, b3, b4, b5, b6))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a3
c f (b4 -> b5 -> b6 -> (b, b2, b3, b4, b5, b6))
-> f b4 -> f (b5 -> b6 -> (b, b2, b3, b4, b5, b6))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a4
d f (b5 -> b6 -> (b, b2, b3, b4, b5, b6))
-> f b5 -> f (b6 -> (b, b2, b3, b4, b5, b6))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a5
e f (b6 -> (b, b2, b3, b4, b5, b6))
-> f b6 -> f (b, b2, b3, b4, b5, b6)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a6
g
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (a,a,a,a,a,a,a) (b,b,b,b,b,b,b) a b@
instance (a~a2, a~a3, a~a4, a~a5, a~a6, a~a7, b~b2, b~b3, b~b4, b~b5, b~b6, b~b7) => Each (a,a2,a3,a4,a5,a6,a7) (b,b2,b3,b4,b5,b6,b7) a b where
  each :: Traversal
  (a, a2, a3, a4, a5, a6, a7) (b, b2, b3, b4, b5, b6, b7) a b
each a -> f b
f ~(a
a,a2
b,a3
c,a4
d,a5
e,a6
g,a7
h) = (,,,,,,) (b
 -> b2 -> b3 -> b4 -> b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
-> f b
-> f (b2
      -> b3 -> b4 -> b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b2 -> b3 -> b4 -> b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
-> f b2
-> f (b3 -> b4 -> b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a2
b f (b3 -> b4 -> b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
-> f b3 -> f (b4 -> b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a3
c f (b4 -> b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
-> f b4 -> f (b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a4
d f (b5 -> b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
-> f b5 -> f (b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a5
e f (b6 -> b7 -> (b, b2, b3, b4, b5, b6, b7))
-> f b6 -> f (b7 -> (b, b2, b3, b4, b5, b6, b7))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a6
g f (b7 -> (b, b2, b3, b4, b5, b6, b7))
-> f b7 -> f (b, b2, b3, b4, b5, b6, b7)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a7
h
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (a,a,a,a,a,a,a,a) (b,b,b,b,b,b,b,b) a b@
instance (a~a2, a~a3, a~a4, a~a5, a~a6, a~a7, a~a8, b~b2, b~b3, b~b4, b~b5, b~b6, b~b7, b~b8) => Each (a,a2,a3,a4,a5,a6,a7,a8) (b,b2,b3,b4,b5,b6,b7,b8) a b where
  each :: Traversal
  (a, a2, a3, a4, a5, a6, a7, a8) (b, b2, b3, b4, b5, b6, b7, b8) a b
each a -> f b
f ~(a
a,a2
b,a3
c,a4
d,a5
e,a6
g,a7
h,a8
i) = (,,,,,,,) (b
 -> b2
 -> b3
 -> b4
 -> b5
 -> b6
 -> b7
 -> b8
 -> (b, b2, b3, b4, b5, b6, b7, b8))
-> f b
-> f (b2
      -> b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> (b, b2, b3, b4, b5, b6, b7, b8))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b2
   -> b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> (b, b2, b3, b4, b5, b6, b7, b8))
-> f b2
-> f (b3
      -> b4 -> b5 -> b6 -> b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a2
b f (b3
   -> b4 -> b5 -> b6 -> b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
-> f b3
-> f (b4
      -> b5 -> b6 -> b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a3
c f (b4 -> b5 -> b6 -> b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
-> f b4
-> f (b5 -> b6 -> b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a4
d f (b5 -> b6 -> b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
-> f b5 -> f (b6 -> b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a5
e f (b6 -> b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
-> f b6 -> f (b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a6
g f (b7 -> b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
-> f b7 -> f (b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a7
h f (b8 -> (b, b2, b3, b4, b5, b6, b7, b8))
-> f b8 -> f (b, b2, b3, b4, b5, b6, b7, b8)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a8
i
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (a,a,a,a,a,a,a,a,a) (b,b,b,b,b,b,b,b,b) a b@
instance (a~a2, a~a3, a~a4, a~a5, a~a6, a~a7, a~a8, a~a9, b~b2, b~b3, b~b4, b~b5, b~b6, b~b7, b~b8, b~b9) => Each (a,a2,a3,a4,a5,a6,a7,a8,a9) (b,b2,b3,b4,b5,b6,b7,b8,b9) a b where
  each :: Traversal
  (a, a2, a3, a4, a5, a6, a7, a8, a9)
  (b, b2, b3, b4, b5, b6, b7, b8, b9)
  a
  b
each a -> f b
f ~(a
a,a2
b,a3
c,a4
d,a5
e,a6
g,a7
h,a8
i,a9
j) = (,,,,,,,,) (b
 -> b2
 -> b3
 -> b4
 -> b5
 -> b6
 -> b7
 -> b8
 -> b9
 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b
-> f (b2
      -> b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> b9
      -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b2
   -> b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> b9
   -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b2
-> f (b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> b9
      -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a2
b f (b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> b9
   -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b3
-> f (b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> b9
      -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a3
c f (b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> b9
   -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b4
-> f (b5
      -> b6 -> b7 -> b8 -> b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a4
d f (b5
   -> b6 -> b7 -> b8 -> b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b5
-> f (b6 -> b7 -> b8 -> b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a5
e f (b6 -> b7 -> b8 -> b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b6
-> f (b7 -> b8 -> b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a6
g f (b7 -> b8 -> b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b7 -> f (b8 -> b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a7
h f (b8 -> b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b8 -> f (b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a8
i f (b9 -> (b, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b9 -> f (b, b2, b3, b4, b5, b6, b7, b8, b9)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a9
j
  {-# INLINE each #-}

-- | @'each' :: ('RealFloat' a, 'RealFloat' b) => 'Traversal' ('Complex' a) ('Complex' b) a b@
instance Each (Complex a) (Complex b) a b where
  each :: Traversal (Complex a) (Complex b) a b
each a -> f b
f (a
a :+ a
b) = b -> b -> Complex b
forall a. a -> a -> Complex a
(:+) (b -> b -> Complex b) -> f b -> f (b -> Complex b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b -> Complex b) -> f b -> f (Complex b)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
b
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' ('Map' c a) ('Map' c b) a b@
instance (c ~ d) => Each (Map c a) (Map d b) a b where
  each :: Traversal (Map c a) (Map d b) a b
each = (a -> f b) -> Map c a -> f (Map c b)
(a -> f b) -> Map c a -> f (Map d b)
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
IndexedTraversal Int (Map c a) (Map c b) a b
traversed
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' ('Map' c a) ('Map' c b) a b@
instance Each (IntMap a) (IntMap b) a b where
  each :: Traversal (IntMap a) (IntMap b) a b
each = (a -> f b) -> IntMap a -> f (IntMap b)
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
IndexedTraversal Int (IntMap a) (IntMap b) a b
traversed
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' ('HashMap' c a) ('HashMap' c b) a b@
instance (c ~ d) => Each (HashMap c a) (HashMap d b) a b where
  each :: Traversal (HashMap c a) (HashMap d b) a b
each = (a -> f b) -> HashMap c a -> f (HashMap c b)
(a -> f b) -> HashMap c a -> f (HashMap d b)
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
IndexedTraversal Int (HashMap c a) (HashMap c b) a b
traversed
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' [a] [b] a b@
instance Each [a] [b] a b where
  each :: Traversal [a] [b] a b
each = (a -> f b) -> [a] -> f [b]
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
IndexedTraversal Int [a] [b] a b
traversed
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' (NonEmpty a) (NonEmpty b) a b@
instance Each (NonEmpty a) (NonEmpty b) a b

-- | @'each' :: 'Traversal' ('Identity' a) ('Identity' b) a b@
instance Each (Identity a) (Identity b) a b

-- | @'each' :: 'Traversal' ('Maybe' a) ('Maybe' b) a b@
instance Each (Maybe a) (Maybe b) a b

-- | @'each' :: 'Traversal' ('Either' a a) ('Either' b b) a b@
--
-- @since 4.18
instance (a~a', b~b') => Each (Either a a') (Either b b') a b where
  each :: Traversal (Either a a') (Either b b') a b
each a -> f b
f (Left a
a)   = b -> Either b b'
forall a b. a -> Either a b
Left (b -> Either b b') -> f b -> f (Either b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a
  each a -> f b
f (Right a'
a ) = b' -> Either b b'
forall a b. b -> Either a b
Right (b' -> Either b b') -> f b' -> f (Either b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a'
a
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' ('Seq' a) ('Seq' b) a b@
instance Each (Seq a) (Seq b) a b where
  each :: Traversal (Seq a) (Seq b) a b
each = (a -> f b) -> Seq a -> f (Seq b)
forall (f :: * -> *) a b.
Traversable f =>
IndexedTraversal Int (f a) (f b) a b
IndexedTraversal Int (Seq a) (Seq b) a b
traversed
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' ('Tree' a) ('Tree' b) a b@
instance Each (Tree a) (Tree b) a b

-- | @'each' :: 'Traversal' ('Vector.Vector' a) ('Vector.Vector' b) a b@
instance Each (Vector.Vector a) (Vector.Vector b) a b where
  each :: Traversal (Vector a) (Vector b) a b
each = (a -> f b) -> Vector a -> f (Vector b)
forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
IndexedTraversal Int (v a) (w b) a b
IndexedTraversal Int (Vector a) (Vector b) a b
vectorTraverse
  {-# INLINE each #-}

-- | @'each' :: ('Prim' a, 'Prim' b) => 'Traversal' ('Prim.Vector' a) ('Prim.Vector' b) a b@
instance (Prim a, Prim b) => Each (Prim.Vector a) (Prim.Vector b) a b where
  each :: Traversal (Vector a) (Vector b) a b
each = (a -> f b) -> Vector a -> f (Vector b)
forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
IndexedTraversal Int (v a) (w b) a b
IndexedTraversal Int (Vector a) (Vector b) a b
vectorTraverse
  {-# INLINE each #-}

-- | @'each' :: ('Storable' a, 'Storable' b) => 'Traversal' ('Storable.Vector' a) ('Storable.Vector' b) a b@
instance (Storable a, Storable b) => Each (Storable.Vector a) (Storable.Vector b) a b where
  each :: Traversal (Vector a) (Vector b) a b
each = (a -> f b) -> Vector a -> f (Vector b)
forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
IndexedTraversal Int (v a) (w b) a b
IndexedTraversal Int (Vector a) (Vector b) a b
vectorTraverse
  {-# INLINE each #-}

-- | @'each' :: ('Unbox' a, 'Unbox' b) => 'Traversal' ('Unboxed.Vector' a) ('Unboxed.Vector' b) a b@
instance (Unbox a, Unbox b) => Each (Unboxed.Vector a) (Unboxed.Vector b) a b where
  each :: Traversal (Vector a) (Vector b) a b
each = (a -> f b) -> Vector a -> f (Vector b)
forall (v :: * -> *) a (w :: * -> *) b.
(Vector v a, Vector w b) =>
IndexedTraversal Int (v a) (w b) a b
IndexedTraversal Int (Vector a) (Vector b) a b
vectorTraverse
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' 'StrictT.Text' 'StrictT.Text' 'Char' 'Char'@
instance (a ~ Char, b ~ Char) => Each StrictT.Text StrictT.Text a b where
  each :: Traversal Text Text a b
each = (a -> f b) -> Text -> f Text
(Char -> f Char) -> Text -> f Text
forall t. IsText t => IndexedTraversal' Int t Char
IndexedTraversal' Int Text Char
text
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' 'LazyT.Text' 'LazyT.Text' 'Char' 'Char'@
instance (a ~ Char, b ~ Char) => Each LazyT.Text LazyT.Text a b where
  each :: Traversal Text Text a b
each = (a -> f b) -> Text -> f Text
(Char -> f Char) -> Text -> f Text
forall t. IsText t => IndexedTraversal' Int t Char
IndexedTraversal' Int Text Char
text
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' 'StrictB.ByteString' 'StrictB.ByteString' 'Word8' 'Word8'@
instance (a ~ Word8, b ~ Word8) => Each StrictB.ByteString StrictB.ByteString a b where
  each :: Traversal ByteString ByteString a b
each = (a -> f b) -> ByteString -> f ByteString
(Word8 -> f Word8) -> ByteString -> f ByteString
IndexedTraversal' Int ByteString Word8
traversedStrictTree
  {-# INLINE each #-}

-- | @'each' :: 'Traversal' 'LazyB.ByteString' 'LazyB.ByteString' 'Word8' 'Word8'@
instance (a ~ Word8, b ~ Word8) => Each LazyB.ByteString LazyB.ByteString a b where
  each :: Traversal ByteString ByteString a b
each = (a -> f b) -> ByteString -> f ByteString
(Word8 -> f Word8) -> ByteString -> f ByteString
IndexedTraversal' Int64 ByteString Word8
traversedLazy
  {-# INLINE each #-}

-- | @'each' :: 'Ix' i => 'Traversal' ('Array' i a) ('Array' i b) a b@
instance (Ix i, i ~ j) => Each (Array i a) (Array j b) a b where
  each :: Traversal (Array i a) (Array j b) a b
each a -> f b
f Array i a
arr = (j, j) -> [(j, b)] -> Array j b
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(i, e)] -> a i e
array (Array j a -> (j, j)
forall i. Ix i => Array i a -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds Array i a
Array j a
arr) ([(j, b)] -> Array j b) -> f [(j, b)] -> f (Array j b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((j, a) -> f (j, b)) -> [(j, a)] -> f [(j, b)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (\(j
i,a
a) -> (,) j
i (b -> (j, b)) -> f b -> f (j, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a) (Array j a -> [(j, a)]
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)]
IArray.assocs Array i a
Array j a
arr)
  {-# INLINE each #-}

-- | @'each' :: ('Ix' i, 'IArray' 'UArray' a, 'IArray' 'UArray' b) => 'Traversal' ('Array' i a) ('Array' i b) a b@
instance (Ix i, IArray UArray a, IArray UArray b, i ~ j) => Each (UArray i a) (UArray j b) a b where
  each :: Traversal (UArray i a) (UArray j b) a b
each a -> f b
f UArray i a
arr = (j, j) -> [(j, b)] -> UArray j b
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(i, e)] -> a i e
array (UArray j a -> (j, j)
forall i. Ix i => UArray i a -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds UArray i a
UArray j a
arr) ([(j, b)] -> UArray j b) -> f [(j, b)] -> f (UArray j b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((j, a) -> f (j, b)) -> [(j, a)] -> f [(j, b)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (\(j
i,a
a) -> (,) j
i (b -> (j, b)) -> f b -> f (j, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a) (UArray j a -> [(j, a)]
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)]
IArray.assocs UArray i a
UArray j a
arr)
  {-# INLINE each #-}

-------------------------------------------------------------------------------
-- strict
-------------------------------------------------------------------------------

-- | @since 4.20
instance (a ~ a', b ~ b') => Each (S.Either a a') (S.Either b b') a b where
    each :: Traversal (Either a a') (Either b b') a b
each a -> f b
f (S.Left a
x)  = b -> Either b b'
forall a b. a -> Either a b
S.Left (b -> Either b b') -> f b -> f (Either b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
x
    each a -> f b
f (S.Right a'
x) = b' -> Either b b'
forall a b. b -> Either a b
S.Right (b' -> Either b b') -> f b' -> f (Either b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a'
x
    {-# INLINE each #-}

-- | @since 4.20
instance (a~a', b~b') => Each (S.Pair a a') (S.Pair b b') a b where
    each :: Traversal (Pair a a') (Pair b b') a b
each a -> f b
f (a
a S.:!: a'
b) = b -> b' -> Pair b b'
forall a b. a -> b -> Pair a b
(S.:!:) (b -> b' -> Pair b b') -> f b -> f (b' -> Pair b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b' -> Pair b b') -> f b' -> f (Pair b b')
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a'
b
    {-# INLINE each #-}

-- | @since 4.20
instance Each (S.Maybe a) (S.Maybe b) a b

-- | @since 4.20
instance (a ~ a', b ~ b') => Each (S.These a a') (S.These b b') a b where
    each :: Traversal (These a a') (These b b') a b
each a -> f b
f (S.This a
a)    = b -> These b b'
forall a b. a -> These a b
S.This (b -> These b b') -> f b -> f (These b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a
    each a -> f b
f (S.That a'
b)    = b' -> These b b'
forall a b. b -> These a b
S.That (b' -> These b b') -> f b' -> f (These b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a'
b
    each a -> f b
f (S.These a
a a'
b) = b -> b' -> These b b'
forall a b. a -> b -> These a b
S.These (b -> b' -> These b b') -> f b -> f (b' -> These b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b' -> These b b') -> f b' -> f (These b b')
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a'
b

-------------------------------------------------------------------------------
-- these
-------------------------------------------------------------------------------

-- | @since 4.20
instance (a ~ a', b ~ b') => Each (These a a') (These b b') a b where
    each :: Traversal (These a a') (These b b') a b
each a -> f b
f (This a
a)    = b -> These b b'
forall a b. a -> These a b
This (b -> These b b') -> f b -> f (These b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a
    each a -> f b
f (That a'
b)    = b' -> These b b'
forall a b. b -> These a b
That (b' -> These b b') -> f b' -> f (These b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a'
b
    each a -> f b
f (These a
a a'
b) = b -> b' -> These b b'
forall a b. a -> b -> These a b
These (b -> b' -> These b b') -> f b -> f (b' -> These b b')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a f (b' -> These b b') -> f b' -> f (These b b')
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
a'
b