Add iforOf{,_}, itraversed, reindexed (#66)

Author: Rufflewind

src/Data/Lens/Fold.purs

@@ -268,3 +268,12 @@ itraverseOf_
   -> s
   -> f Unit
 itraverseOf_ p f = ifoldrOf p (\i a fu -> void (f i a) *> fu) (pure unit)
+
+-- | Flipped version of `itraverseOf_`.
+iforOf_
+  :: forall i f s t a b r. (Applicative f)
+  => IndexedFold (Endo (f Unit)) i s t a b
+  -> s
+  -> (i -> a -> f r)
+  -> f Unit
+iforOf_ = flip <<< itraverseOf_

src/Data/Lens/Indexed.purs

@@ -5,10 +5,14 @@ import Prelude
 import Control.Monad.State (modify, get, evalState)
 
 import Data.Functor.Compose (Compose(..))
+import Data.Lens.Iso.Newtype (_Newtype)
+import Data.Lens.Setter ((%~))
 import Data.Lens.Types (wander, Optic, IndexedOptic, Indexed(..), Traversal, IndexedTraversal)
 import Data.Newtype (unwrap)
-import Data.Profunctor (class Profunctor, dimap)
+import Data.Profunctor (class Profunctor, dimap, lmap)
 import Data.Profunctor.Star (Star(..))
+import Data.Profunctor.Strong (first)
+import Data.TraversableWithIndex (class TraversableWithIndex, traverseWithIndex)
 import Data.Tuple (curry, fst, snd)
 
 -- | Converts an `IndexedOptic` to an `Optic` by forgetting indices.
@@ -26,13 +30,25 @@ asIndex
   -> Optic p s t i b
 asIndex l = l <<< Indexed <<< dimap fst id
 
+-- | Remap the index.
+reindexed :: forall p i j r a b . Profunctor p =>
+             (i -> j) -> (Indexed p i a b -> r) -> Indexed p j a b -> r
+reindexed ij = (_ <<< _Newtype %~ lmap (first ij))
+
 -- | Converts a `lens`-like indexed traversal to an `IndexedTraversal`.
 iwander
   :: forall i s t a b
    . (forall f. Applicative f => (i -> a -> f b) -> s -> f t)
   -> IndexedTraversal i s t a b
 iwander itr = wander (\f s -> itr (curry f) s) <<< unwrap
 
+-- | Traverses over a `TraversableWithIndex` container.
+itraversed
+  :: forall i t a b
+   . TraversableWithIndex i t
+  => IndexedTraversal i (t a) (t b) a b
+itraversed = iwander traverseWithIndex
+
 -- | Converts a `Traversal` to an `IndexedTraversal` by using the integer
 -- | positions as indices.
 positions

src/Data/Lens/Traversal.purs

@@ -84,3 +84,13 @@ itraverseOf
   -> s
   -> f t
 itraverseOf t = under Star (t <<< Indexed) <<< uncurry
+
+-- | Flipped version of `itraverseOf`.
+iforOf
+  :: forall f i s t a b
+  . Applicative f
+  => IndexedOptic (Star f) i s t a b
+  -> s
+  -> (i -> a -> f b)
+  -> f t
+iforOf = flip <<< itraverseOf

test/Main.purs

@@ -11,10 +11,11 @@ import Data.Lens.Fold ((^?))
 import Data.Lens.Fold.Partial ((^?!), (^@?!))
 import Data.Lens.Grate (Grate, cloneGrate, grate, zipWithOf)
 import Data.Lens.Index (ix)
+import Data.Lens.Indexed (itraversed, reindexed)
 import Data.Lens.Lens (ilens, IndexedLens, cloneIndexedLens)
 import Data.Lens.Record (prop)
 import Data.Lens.Setter (iover)
-import Data.Lens.Zoom (Traversal, Traversal', Lens, Lens', zoom)
+import Data.Lens.Zoom (IndexedTraversal', Traversal, Traversal', Lens, Lens', zoom)
 import Data.Maybe (Maybe(..))
 import Data.Symbol (SProxy(..))
 import Data.Tuple (Tuple(..), fst, snd)
@@ -39,6 +40,8 @@ bars = foo <<< _Just <<< bar <<< traversed
 type BarRec = { foo :: Array (Either { bar :: Array Int } String) }
 data Bar = Bar BarRec
 
+newtype BarIndex = BarIndex Int
+
 _Bar :: Lens' Bar BarRec
 _Bar = lens (\(Bar rec) -> rec) (\_ -> Bar)
 
@@ -51,6 +54,10 @@ _0Justbar = _Bar <<< foo <<< ix 0
 _1bars :: Traversal' Bar Int
 _1bars = _0Justbar <<< _Left <<< bar <<< ix 1
 
+_2Justbared :: IndexedTraversal' BarIndex Bar
+                                 (Either { bar :: Array Int } String)
+_2Justbared = _Bar <<< foo <<< reindexed BarIndex itraversed
+
 -- Tests state using zoom
 stateTest :: Tuple Int String
 stateTest = evalState go (Tuple 4 ["Foo", "Bar"]) where