-- |
-- Module: Optics.Each.Core
-- Description: An 'IxTraversal' for each element of a (potentially monomorphic) container.
--
-- This module defines the 'Each' class, which provides an 'IxTraversal' that
-- extracts 'each' element of a (potentially monomorphic) container.
--
-- Note that orphan instances for this class are defined in the @Optics.Each@
-- module from @optics-extra@, so if you are not simply depending on @optics@
-- you may wish to import that module instead.
--
{-# LANGUAGE UndecidableInstances #-}
module Optics.Each.Core
  (
  -- * Each
    Each(..)
  ) where

import Data.Complex (Complex (..))
import Data.Functor.Identity (Identity (..))
import Data.List.NonEmpty (NonEmpty (..))
import Data.Tree (Tree (..))
import Data.Ix (Ix)

import Data.Array (Array)
import Data.IntMap (IntMap)
import qualified Data.IntMap as IntMap
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Sequence (Seq)

import Optics.IxLens
import Optics.IxTraversal
import Optics.Optic

-- | Extract 'each' element of a (potentially monomorphic) container.
--
-- >>> over each (*10) (1,2,3)
-- (10,20,30)
--
-- >>> iover each (\i a -> a*10 + succ i) (1,2,3)
-- (11,22,33)
--
class Each i s t a b | s -> i a, t -> i b, s b -> t, t a -> s where
  each :: IxTraversal i s t a b

  default each
    :: (TraversableWithIndex i g, s ~ g a, t ~ g b)
    => IxTraversal i s t a b
  each = IxTraversal i s t a b
IxTraversal i (g a) (g b) a b
forall i (f :: * -> *) a b.
TraversableWithIndex i f =>
IxTraversal i (f a) (f b) a b
itraversed
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a) (b, b) a b@
instance
  (a ~ a1,
   b ~ b1
  ) => Each Int (a, a1)
                (b, b1) a b where
  each :: IxTraversal Int (a, a1) (b, b1) a b
each = IxTraversalVL Int (a, a1) (b, b1) a b
-> IxTraversal Int (a, a1) (b, b1) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL Int (a, a1) (b, b1) a b
 -> IxTraversal Int (a, a1) (b, b1) a b)
-> IxTraversalVL Int (a, a1) (b, b1) a b
-> IxTraversal Int (a, a1) (b, b1) a b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1) ->
    (,) (b -> b1 -> (b, b1)) -> f b -> f (b1 -> (b, b1))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1 -> (b, b1)) -> f b1 -> f (b, b1)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> a -> f b
f Int
1 a
a1
a1
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a, a) (b, b, b) a b@
instance
  (a ~ a1, a ~ a2,
   b ~ b1, b ~ b2
  ) => Each Int (a, a1, a2)
                (b, b1, b2) a b where
  each :: IxTraversal Int (a, a1, a2) (b, b1, b2) a b
each = IxTraversalVL Int (a, a1, a2) (b, b1, b2) a b
-> IxTraversal Int (a, a1, a2) (b, b1, b2) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL Int (a, a1, a2) (b, b1, b2) a b
 -> IxTraversal Int (a, a1, a2) (b, b1, b2) a b)
-> IxTraversalVL Int (a, a1, a2) (b, b1, b2) a b
-> IxTraversal Int (a, a1, a2) (b, b1, b2) a b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1, a2
a2) ->
    (,,) (b -> b1 -> b2 -> (b, b1, b2))
-> f b -> f (b1 -> b2 -> (b, b1, b2))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1 -> b2 -> (b, b1, b2)) -> f b1 -> f (b2 -> (b, b1, b2))
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> a -> f b
f Int
1 a
a1
a1 f (b2 -> (b, b1, b2)) -> f b2 -> f (b, b1, b2)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> a -> f b
f Int
2 a
a2
a2
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a, a, a) (b, b, b, b) a b@
instance
  (a ~ a1, a ~ a2, a ~ a3,
   b ~ b1, b ~ b2, b ~ b3
  ) => Each Int (a, a1, a2, a3)
                (b, b1, b2, b3) a b where
  each :: IxTraversal Int (a, a1, a2, a3) (b, b1, b2, b3) a b
each = IxTraversalVL Int (a, a1, a2, a3) (b, b1, b2, b3) a b
-> IxTraversal Int (a, a1, a2, a3) (b, b1, b2, b3) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL Int (a, a1, a2, a3) (b, b1, b2, b3) a b
 -> IxTraversal Int (a, a1, a2, a3) (b, b1, b2, b3) a b)
-> IxTraversalVL Int (a, a1, a2, a3) (b, b1, b2, b3) a b
-> IxTraversal Int (a, a1, a2, a3) (b, b1, b2, b3) a b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1, a2
a2, a3
a3) ->
    (,,,) (b -> b1 -> b2 -> b3 -> (b, b1, b2, b3))
-> f b -> f (b1 -> b2 -> b3 -> (b, b1, b2, b3))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1 -> b2 -> b3 -> (b, b1, b2, b3))
-> f b1 -> f (b2 -> b3 -> (b, b1, 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
<*> Int -> a -> f b
f Int
1 a
a1
a1 f (b2 -> b3 -> (b, b1, b2, b3))
-> f b2 -> f (b3 -> (b, b1, 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
<*> Int -> a -> f b
f Int
2 a
a2
a2 f (b3 -> (b, b1, b2, b3)) -> f b3 -> f (b, b1, 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
<*> Int -> a -> f b
f Int
3 a
a3
a3
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a, a, a, a) (b, b, b, b, b) a b@
instance
  (a ~ a1, a ~ a2, a ~ a3, a ~ a4,
   b ~ b1, b ~ b2, b ~ b3, b ~ b4
  ) => Each Int (a, a1, a2, a3, a4)
                (b, b1, b2, b3, b4) a b where
  each :: IxTraversal Int (a, a1, a2, a3, a4) (b, b1, b2, b3, b4) a b
each = IxTraversalVL Int (a, a1, a2, a3, a4) (b, b1, b2, b3, b4) a b
-> IxTraversal Int (a, a1, a2, a3, a4) (b, b1, b2, b3, b4) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL Int (a, a1, a2, a3, a4) (b, b1, b2, b3, b4) a b
 -> IxTraversal Int (a, a1, a2, a3, a4) (b, b1, b2, b3, b4) a b)
-> IxTraversalVL Int (a, a1, a2, a3, a4) (b, b1, b2, b3, b4) a b
-> IxTraversal Int (a, a1, a2, a3, a4) (b, b1, b2, b3, b4) a b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1, a2
a2, a3
a3, a4
a4) ->
    (,,,,) (b -> b1 -> b2 -> b3 -> b4 -> (b, b1, b2, b3, b4))
-> f b -> f (b1 -> b2 -> b3 -> b4 -> (b, b1, b2, b3, b4))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1 -> b2 -> b3 -> b4 -> (b, b1, b2, b3, b4))
-> f b1 -> f (b2 -> b3 -> b4 -> (b, b1, 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
<*> Int -> a -> f b
f Int
1 a
a1
a1 f (b2 -> b3 -> b4 -> (b, b1, b2, b3, b4))
-> f b2 -> f (b3 -> b4 -> (b, b1, 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
<*> Int -> a -> f b
f Int
2 a
a2
a2 f (b3 -> b4 -> (b, b1, b2, b3, b4))
-> f b3 -> f (b4 -> (b, b1, 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
<*> Int -> a -> f b
f Int
3 a
a3
a3 f (b4 -> (b, b1, b2, b3, b4)) -> f b4 -> f (b, b1, 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
<*> Int -> a -> f b
f Int
4 a
a4
a4
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a, a, a, a, a) (b, b, b, b, b, b) a b@
instance
  (a ~ a1, a ~ a2, a ~ a3, a ~ a4, a ~ a5,
   b ~ b1, b ~ b2, b ~ b3, b ~ b4, b ~ b5
  ) => Each Int (a, a1, a2, a3, a4, a5)
                (b, b1, b2, b3, b4, b5) a b where
  each :: IxTraversal Int (a, a1, a2, a3, a4, a5) (b, b1, b2, b3, b4, b5) a b
each = IxTraversalVL
  Int (a, a1, a2, a3, a4, a5) (b, b1, b2, b3, b4, b5) a b
-> IxTraversal
     Int (a, a1, a2, a3, a4, a5) (b, b1, b2, b3, b4, b5) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL
   Int (a, a1, a2, a3, a4, a5) (b, b1, b2, b3, b4, b5) a b
 -> IxTraversal
      Int (a, a1, a2, a3, a4, a5) (b, b1, b2, b3, b4, b5) a b)
-> IxTraversalVL
     Int (a, a1, a2, a3, a4, a5) (b, b1, b2, b3, b4, b5) a b
-> IxTraversal
     Int (a, a1, a2, a3, a4, a5) (b, b1, b2, b3, b4, b5) a b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1, a2
a2, a3
a3, a4
a4, a5
a5) ->
    (,,,,,) (b -> b1 -> b2 -> b3 -> b4 -> b5 -> (b, b1, b2, b3, b4, b5))
-> f b -> f (b1 -> b2 -> b3 -> b4 -> b5 -> (b, b1, b2, b3, b4, b5))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1 -> b2 -> b3 -> b4 -> b5 -> (b, b1, b2, b3, b4, b5))
-> f b1 -> f (b2 -> b3 -> b4 -> b5 -> (b, b1, 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
<*> Int -> a -> f b
f Int
1 a
a1
a1 f (b2 -> b3 -> b4 -> b5 -> (b, b1, b2, b3, b4, b5))
-> f b2 -> f (b3 -> b4 -> b5 -> (b, b1, 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
<*> Int -> a -> f b
f Int
2 a
a2
a2 f (b3 -> b4 -> b5 -> (b, b1, b2, b3, b4, b5))
-> f b3 -> f (b4 -> b5 -> (b, b1, 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
<*> Int -> a -> f b
f Int
3 a
a3
a3 f (b4 -> b5 -> (b, b1, b2, b3, b4, b5))
-> f b4 -> f (b5 -> (b, b1, 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
<*> Int -> a -> f b
f Int
4 a
a4
a4
            f (b5 -> (b, b1, b2, b3, b4, b5))
-> f b5 -> f (b, b1, 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
<*> Int -> a -> f b
f Int
5 a
a5
a5
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a, a, a, a, a, a) (b, b, b, b, b, b, b)
-- a b@
instance
  (a ~ a1, a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6,
   b ~ b1, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6
  ) => Each Int (a, a1, a2, a3, a4, a5, a6)
                (b, b1, b2, b3, b4, b5, b6) a b where
  each :: IxTraversal
  Int (a, a1, a2, a3, a4, a5, a6) (b, b1, b2, b3, b4, b5, b6) a b
each = IxTraversalVL
  Int (a, a1, a2, a3, a4, a5, a6) (b, b1, b2, b3, b4, b5, b6) a b
-> IxTraversal
     Int (a, a1, a2, a3, a4, a5, a6) (b, b1, b2, b3, b4, b5, b6) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL
   Int (a, a1, a2, a3, a4, a5, a6) (b, b1, b2, b3, b4, b5, b6) a b
 -> IxTraversal
      Int (a, a1, a2, a3, a4, a5, a6) (b, b1, b2, b3, b4, b5, b6) a b)
-> IxTraversalVL
     Int (a, a1, a2, a3, a4, a5, a6) (b, b1, b2, b3, b4, b5, b6) a b
-> IxTraversal
     Int (a, a1, a2, a3, a4, a5, a6) (b, b1, b2, b3, b4, b5, b6) a b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1, a2
a2, a3
a3, a4
a4, a5
a5, a6
a6) ->
    (,,,,,,) (b
 -> b1 -> b2 -> b3 -> b4 -> b5 -> b6 -> (b, b1, b2, b3, b4, b5, b6))
-> f b
-> f (b1
      -> b2 -> b3 -> b4 -> b5 -> b6 -> (b, b1, b2, b3, b4, b5, b6))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1 -> b2 -> b3 -> b4 -> b5 -> b6 -> (b, b1, b2, b3, b4, b5, b6))
-> f b1
-> f (b2 -> b3 -> b4 -> b5 -> b6 -> (b, b1, 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
<*> Int -> a -> f b
f Int
1 a
a1
a1 f (b2 -> b3 -> b4 -> b5 -> b6 -> (b, b1, b2, b3, b4, b5, b6))
-> f b2 -> f (b3 -> b4 -> b5 -> b6 -> (b, b1, 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
<*> Int -> a -> f b
f Int
2 a
a2
a2 f (b3 -> b4 -> b5 -> b6 -> (b, b1, b2, b3, b4, b5, b6))
-> f b3 -> f (b4 -> b5 -> b6 -> (b, b1, 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
<*> Int -> a -> f b
f Int
3 a
a3
a3 f (b4 -> b5 -> b6 -> (b, b1, b2, b3, b4, b5, b6))
-> f b4 -> f (b5 -> b6 -> (b, b1, 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
<*> Int -> a -> f b
f Int
4 a
a4
a4
             f (b5 -> b6 -> (b, b1, b2, b3, b4, b5, b6))
-> f b5 -> f (b6 -> (b, b1, 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
<*> Int -> a -> f b
f Int
5 a
a5
a5 f (b6 -> (b, b1, b2, b3, b4, b5, b6))
-> f b6 -> f (b, b1, 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
<*> Int -> a -> f b
f Int
6 a
a6
a6
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a, a, a, a, a, a, a) (b, b, b, b, b, b,
-- b, b) a b@
instance
  (a ~ a1, a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7,
   b ~ b1, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6, b ~ b7
  ) => Each Int (a, a1, a2, a3, a4, a5, a6, a7)
                (b, b1, b2, b3, b4, b5, b6, b7) a b where
  each :: IxTraversal
  Int
  (a, a1, a2, a3, a4, a5, a6, a7)
  (b, b1, b2, b3, b4, b5, b6, b7)
  a
  b
each = IxTraversalVL
  Int
  (a, a1, a2, a3, a4, a5, a6, a7)
  (b, b1, b2, b3, b4, b5, b6, b7)
  a
  b
-> IxTraversal
     Int
     (a, a1, a2, a3, a4, a5, a6, a7)
     (b, b1, b2, b3, b4, b5, b6, b7)
     a
     b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL
   Int
   (a, a1, a2, a3, a4, a5, a6, a7)
   (b, b1, b2, b3, b4, b5, b6, b7)
   a
   b
 -> IxTraversal
      Int
      (a, a1, a2, a3, a4, a5, a6, a7)
      (b, b1, b2, b3, b4, b5, b6, b7)
      a
      b)
-> IxTraversalVL
     Int
     (a, a1, a2, a3, a4, a5, a6, a7)
     (b, b1, b2, b3, b4, b5, b6, b7)
     a
     b
-> IxTraversal
     Int
     (a, a1, a2, a3, a4, a5, a6, a7)
     (b, b1, b2, b3, b4, b5, b6, b7)
     a
     b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1, a2
a2, a3
a3, a4
a4, a5
a5, a6
a6, a7
a7) ->
    (,,,,,,,) (b
 -> b1
 -> b2
 -> b3
 -> b4
 -> b5
 -> b6
 -> b7
 -> (b, b1, b2, b3, b4, b5, b6, b7))
-> f b
-> f (b1
      -> b2
      -> b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> (b, b1, b2, b3, b4, b5, b6, b7))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1
   -> b2
   -> b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> (b, b1, b2, b3, b4, b5, b6, b7))
-> f b1
-> f (b2
      -> b3 -> b4 -> b5 -> b6 -> b7 -> (b, b1, 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
<*> Int -> a -> f b
f Int
1 a
a1
a1 f (b2
   -> b3 -> b4 -> b5 -> b6 -> b7 -> (b, b1, b2, b3, b4, b5, b6, b7))
-> f b2
-> f (b3
      -> b4 -> b5 -> b6 -> b7 -> (b, b1, 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
<*> Int -> a -> f b
f Int
2 a
a2
a2 f (b3 -> b4 -> b5 -> b6 -> b7 -> (b, b1, b2, b3, b4, b5, b6, b7))
-> f b3
-> f (b4 -> b5 -> b6 -> b7 -> (b, b1, 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
<*> Int -> a -> f b
f Int
3 a
a3
a3 f (b4 -> b5 -> b6 -> b7 -> (b, b1, b2, b3, b4, b5, b6, b7))
-> f b4 -> f (b5 -> b6 -> b7 -> (b, b1, 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
<*> Int -> a -> f b
f Int
4 a
a4
a4
              f (b5 -> b6 -> b7 -> (b, b1, b2, b3, b4, b5, b6, b7))
-> f b5 -> f (b6 -> b7 -> (b, b1, 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
<*> Int -> a -> f b
f Int
5 a
a5
a5 f (b6 -> b7 -> (b, b1, b2, b3, b4, b5, b6, b7))
-> f b6 -> f (b7 -> (b, b1, 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
<*> Int -> a -> f b
f Int
6 a
a6
a6 f (b7 -> (b, b1, b2, b3, b4, b5, b6, b7))
-> f b7 -> f (b, b1, 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
<*> Int -> a -> f b
f Int
7 a
a7
a7
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a, a, a, a, a, a, a, a) (b, b, b, b, b,
-- b, b, b, b) a b@
instance
  (a ~ a1, a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7, a ~ a8,
   b ~ b1, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6, b ~ b7, b ~ b8
  ) => Each Int (a, a1, a2, a3, a4, a5, a6, a7, a8)
                (b, b1, b2, b3, b4, b5, b6, b7, b8) a b where
  each :: IxTraversal
  Int
  (a, a1, a2, a3, a4, a5, a6, a7, a8)
  (b, b1, b2, b3, b4, b5, b6, b7, b8)
  a
  b
each = IxTraversalVL
  Int
  (a, a1, a2, a3, a4, a5, a6, a7, a8)
  (b, b1, b2, b3, b4, b5, b6, b7, b8)
  a
  b
-> IxTraversal
     Int
     (a, a1, a2, a3, a4, a5, a6, a7, a8)
     (b, b1, b2, b3, b4, b5, b6, b7, b8)
     a
     b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL
   Int
   (a, a1, a2, a3, a4, a5, a6, a7, a8)
   (b, b1, b2, b3, b4, b5, b6, b7, b8)
   a
   b
 -> IxTraversal
      Int
      (a, a1, a2, a3, a4, a5, a6, a7, a8)
      (b, b1, b2, b3, b4, b5, b6, b7, b8)
      a
      b)
-> IxTraversalVL
     Int
     (a, a1, a2, a3, a4, a5, a6, a7, a8)
     (b, b1, b2, b3, b4, b5, b6, b7, b8)
     a
     b
-> IxTraversal
     Int
     (a, a1, a2, a3, a4, a5, a6, a7, a8)
     (b, b1, b2, b3, b4, b5, b6, b7, b8)
     a
     b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1, a2
a2, a3
a3, a4
a4, a5
a5, a6
a6, a7
a7, a8
a8) ->
    (,,,,,,,,) (b
 -> b1
 -> b2
 -> b3
 -> b4
 -> b5
 -> b6
 -> b7
 -> b8
 -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b
-> f (b1
      -> b2
      -> b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1
   -> b2
   -> b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b1
-> f (b2
      -> b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> (b, b1, 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
<*> Int -> a -> f b
f Int
1 a
a1
a1 f (b2
   -> b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b2
-> f (b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> (b, b1, 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
<*> Int -> a -> f b
f Int
2 a
a2
a2 f (b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b3
-> f (b4
      -> b5 -> b6 -> b7 -> b8 -> (b, b1, 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
<*> Int -> a -> f b
f Int
3 a
a3
a3 f (b4
   -> b5 -> b6 -> b7 -> b8 -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b4
-> f (b5 -> b6 -> b7 -> b8 -> (b, b1, 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
<*> Int -> a -> f b
f Int
4 a
a4
a4
               f (b5 -> b6 -> b7 -> b8 -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b5
-> f (b6 -> b7 -> b8 -> (b, b1, 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
<*> Int -> a -> f b
f Int
5 a
a5
a5 f (b6 -> b7 -> b8 -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b6 -> f (b7 -> b8 -> (b, b1, 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
<*> Int -> a -> f b
f Int
6 a
a6
a6 f (b7 -> b8 -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b7 -> f (b8 -> (b, b1, 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
<*> Int -> a -> f b
f Int
7 a
a7
a7 f (b8 -> (b, b1, b2, b3, b4, b5, b6, b7, b8))
-> f b8 -> f (b, b1, 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
<*> Int -> a -> f b
f Int
8 a
a8
a8
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' (a, a, a, a, a, a, a, a, a, a) (b, b, b, b,
-- b, b, b, b, b, b) a b@
instance
  (a ~ a1, a ~ a2, a ~ a3, a ~ a4, a ~ a5, a ~ a6, a ~ a7, a ~ a8, a ~ a9,
   b ~ b1, b ~ b2, b ~ b3, b ~ b4, b ~ b5, b ~ b6, b ~ b7, b ~ b8, b ~ b9
  ) => Each Int (a, a1, a2, a3, a4, a5, a6, a7, a8, a9)
                (b, b1, b2, b3, b4, b5, b6, b7, b8, b9) a b where
  each :: IxTraversal
  Int
  (a, a1, a2, a3, a4, a5, a6, a7, a8, a9)
  (b, b1, b2, b3, b4, b5, b6, b7, b8, b9)
  a
  b
each = IxTraversalVL
  Int
  (a, a1, a2, a3, a4, a5, a6, a7, a8, a9)
  (b, b1, b2, b3, b4, b5, b6, b7, b8, b9)
  a
  b
-> IxTraversal
     Int
     (a, a1, a2, a3, a4, a5, a6, a7, a8, a9)
     (b, b1, b2, b3, b4, b5, b6, b7, b8, b9)
     a
     b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL
   Int
   (a, a1, a2, a3, a4, a5, a6, a7, a8, a9)
   (b, b1, b2, b3, b4, b5, b6, b7, b8, b9)
   a
   b
 -> IxTraversal
      Int
      (a, a1, a2, a3, a4, a5, a6, a7, a8, a9)
      (b, b1, b2, b3, b4, b5, b6, b7, b8, b9)
      a
      b)
-> IxTraversalVL
     Int
     (a, a1, a2, a3, a4, a5, a6, a7, a8, a9)
     (b, b1, b2, b3, b4, b5, b6, b7, b8, b9)
     a
     b
-> IxTraversal
     Int
     (a, a1, a2, a3, a4, a5, a6, a7, a8, a9)
     (b, b1, b2, b3, b4, b5, b6, b7, b8, b9)
     a
     b
forall a b. (a -> b) -> a -> b
$ \Int -> a -> f b
f (a
a0, a1
a1, a2
a2, a3
a3, a4
a4, a5
a5, a6
a6, a7
a7, a8
a8, a9
a9) ->
    (,,,,,,,,,) (b
 -> b1
 -> b2
 -> b3
 -> b4
 -> b5
 -> b6
 -> b7
 -> b8
 -> b9
 -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b
-> f (b1
      -> b2
      -> b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> b9
      -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> f b
f Int
0 a
a0 f (b1
   -> b2
   -> b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> b9
   -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b1
-> f (b2
      -> b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> b9
      -> (b, b1, 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
<*> Int -> a -> f b
f Int
1 a
a1
a1 f (b2
   -> b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> b9
   -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b2
-> f (b3
      -> b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> b9
      -> (b, b1, 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
<*> Int -> a -> f b
f Int
2 a
a2
a2 f (b3
   -> b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> b9
   -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b3
-> f (b4
      -> b5
      -> b6
      -> b7
      -> b8
      -> b9
      -> (b, b1, 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
<*> Int -> a -> f b
f Int
3 a
a3
a3 f (b4
   -> b5
   -> b6
   -> b7
   -> b8
   -> b9
   -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b4
-> f (b5
      -> b6 -> b7 -> b8 -> b9 -> (b, b1, 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
<*> Int -> a -> f b
f Int
4 a
a4
a4
                f (b5
   -> b6 -> b7 -> b8 -> b9 -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b5
-> f (b6
      -> b7 -> b8 -> b9 -> (b, b1, 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
<*> Int -> a -> f b
f Int
5 a
a5
a5 f (b6 -> b7 -> b8 -> b9 -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b6
-> f (b7 -> b8 -> b9 -> (b, b1, 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
<*> Int -> a -> f b
f Int
6 a
a6
a6 f (b7 -> b8 -> b9 -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b7 -> f (b8 -> b9 -> (b, b1, 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
<*> Int -> a -> f b
f Int
7 a
a7
a7 f (b8 -> b9 -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b8 -> f (b9 -> (b, b1, 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
<*> Int -> a -> f b
f Int
8 a
a8
a8 f (b9 -> (b, b1, b2, b3, b4, b5, b6, b7, b8, b9))
-> f b9 -> f (b, b1, 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
<*> Int -> a -> f b
f Int
9 a
a9
a9
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' ('Either' () ()) ('Either' a a) ('Either' b b) a
-- b@
instance
  (a ~ a', b ~ b'
  ) => Each (Either () ()) (Either a a') (Either b b') a b where
  each :: IxTraversal (Either () ()) (Either a a') (Either b b') a b
each = Optic
  A_Lens (WithIx (Either () ())) (Either a a') (Either b b') a b
-> IxTraversal (Either () ()) (Either a a') (Either b b') a b
forall destKind srcKind (is :: IxList) s t a b.
Is srcKind destKind =>
Optic srcKind is s t a b -> Optic destKind is s t a b
castOptic IxLens (Either () ()) (Either a a) (Either b b) a b
Optic
  A_Lens (WithIx (Either () ())) (Either a a') (Either b b') a b
forall a b. IxLens (Either () ()) (Either a a) (Either b b) a b
chosen
  {-# INLINE[1] each #-}

-- | @'each' :: ('RealFloat' a, 'RealFloat' b) => 'IxTraversal' (Either () ())
-- ('Complex' a) ('Complex' b) a b@
instance Each (Either () ()) (Complex a) (Complex b) a b where
  each :: IxTraversal (Either () ()) (Complex a) (Complex b) a b
each = IxTraversalVL (Either () ()) (Complex a) (Complex b) a b
-> IxTraversal (Either () ()) (Complex a) (Complex b) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (IxTraversalVL (Either () ()) (Complex a) (Complex b) a b
 -> IxTraversal (Either () ()) (Complex a) (Complex b) a b)
-> IxTraversalVL (Either () ()) (Complex a) (Complex b) a b
-> IxTraversal (Either () ()) (Complex a) (Complex b) a b
forall a b. (a -> b) -> a -> b
$ \Either () () -> 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
<$> Either () () -> a -> f b
f (() -> Either () ()
forall a b. a -> Either a b
Left ()) 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
<*> Either () () -> a -> f b
f (() -> Either () ()
forall a b. b -> Either a b
Right ()) a
b
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' k ('Map' k a) ('Map' k b) a b@
instance k ~ k' => Each k (Map k a) (Map k' b) a b where
  -- traverseWithKey has best performance for all flavours for some reason.
  each :: IxTraversal k (Map k a) (Map k' b) a b
each = IxTraversalVL k (Map k a) (Map k' b) a b
-> IxTraversal k (Map k a) (Map k' b) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (k -> a -> f b) -> Map k a -> f (Map k b)
(k -> a -> f b) -> Map k a -> f (Map k' b)
IxTraversalVL k (Map k a) (Map k' b) a b
forall (t :: * -> *) k a b.
Applicative t =>
(k -> a -> t b) -> Map k a -> t (Map k b)
Map.traverseWithKey
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' ('IntMap' a) ('IntMap' b) a b@
instance Each Int (IntMap a) (IntMap b) a b where
  -- traverseWithKey has best performance for all flavours for some reason.
  each :: IxTraversal Int (IntMap a) (IntMap b) a b
each = IxTraversalVL Int (IntMap a) (IntMap b) a b
-> IxTraversal Int (IntMap a) (IntMap b) a b
forall i s t a b. IxTraversalVL i s t a b -> IxTraversal i s t a b
itraversalVL (Int -> a -> f b) -> IntMap a -> f (IntMap b)
IxTraversalVL Int (IntMap a) (IntMap b) a b
forall (t :: * -> *) a b.
Applicative t =>
(Int -> a -> t b) -> IntMap a -> t (IntMap b)
IntMap.traverseWithKey
  {-# INLINE[1] each #-}

-- | @'each' :: 'IxTraversal' 'Int' [a] [b] a b@
instance Each Int [a] [b] a b

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

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

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

-- | @'each' :: 'IxTraversal' 'Int' ('Seq' a) ('Seq' b) a b@
instance Each Int (Seq a) (Seq b) a b

-- | @'each' :: 'IxTraversal' [Int] ('Tree' a) ('Tree' b) a b@
instance Each [Int] (Tree a) (Tree b) a b

-- | @'each' :: 'Ix' i => 'IxTraversal' i ('Array' i a) ('Array' i b) a b@
instance (Ix i, i ~ j) => Each i (Array i a) (Array j b) a b

-- $setup
-- >>> import Optics.Core