both & takeBoth (#74)

* both & takeBoth

* both: combine two `Lens`
* takeBoth: combine two `Getters`

* Remove both lens.

Author: Marcin Szamotulski

src/Data/Lens.purs

@@ -30,6 +30,6 @@ import Data.Lens.Prism (APrism, APrism', Prism, Prism', Review, Review', clonePr
 import Data.Lens.Traversal (Traversal, Traversal', element, elementsOf, failover, itraverseOf, sequenceOf, traverseOf, traversed)
 import Data.Lens.Types (class Wander, ALens, ALens', APrism, APrism', AnIso, AnIso', Fold, Fold', Getter, Getter', IndexedFold, IndexedFold', IndexedGetter, IndexedGetter', IndexedOptic, IndexedOptic', IndexedSetter, IndexedSetter', IndexedTraversal, IndexedTraversal', Iso, Iso', Lens, Lens', Optic, Optic', Prism, Prism', Review, Review', Setter, Setter', Traversal, Traversal', Exchange(..), Forget(..), Indexed(..), Market(..), Re(..), Shop(..), Tagged(..), wander)
 import Data.Lens.Setter (IndexedSetter, Setter, Setter', Indexed(..), addModifying, addOver, appendModifying, appendOver, assign, assignJust, conjModifying, conjOver, disjModifying, disjOver, divModifying, divOver, iover, modifying, mulModifying, mulOver, over, set, setJust, subModifying, subOver, (%=), (%~), (&&=), (&&~), (*=), (*~), (++=), (++~), (+=), (+~), (-=), (-~), (.=), (.~), (//=), (//~), (<>=), (<>~), (?=), (?~), (||=), (||~))
-import Data.Lens.Getter (Fold, Getter, IndexedFold, IndexedGetter, Optic, Indexed(..), iuse, iview, to, use, view, viewOn, (^.))
+import Data.Lens.Getter (Fold, Getter, IndexedFold, IndexedGetter, Optic, Indexed(..), iuse, iview, to, takeBoth, use, view, viewOn, (^.))
 import Data.Lens.Fold (Fold, Fold', allOf, andOf, anyOf, elemOf, filtered, findOf, firstOf, foldMapOf, foldOf, folded, foldlOf, foldrOf, has, hasn't, iallOf, ianyOf, ifoldMapOf, ifoldlOf, ifoldrOf, itoListOf, itraverseOf_, lastOf, lengthOf, maximumOf, minimumOf, notElemOf, orOf, preview, previewOn, productOf, replicated, sequenceOf_, sumOf, toListOf, toListOfOn, unfolded, (^..), (^?))
 import Data.Lens.Common (_1, _2, _Just, _Left, _Nothing, _Right, first, left, right, second, united)

src/Data/Lens/Getter.purs

@@ -1,17 +1,17 @@
 -- | This module defines functions for working with getters.
 module Data.Lens.Getter
   ( (^.), viewOn
-  , view, to, use, iview, iuse
+  , view, to, takeBoth, use, iview, iuse
   , module Data.Lens.Types
   ) where
 
 import Prelude
 
 import Control.Monad.State.Class (class MonadState, gets)
-
 import Data.Lens.Internal.Forget (Forget(..))
 import Data.Lens.Types (Getter, Fold, Optic, IndexedGetter, Indexed(..), IndexedFold)
 import Data.Newtype (unwrap)
+import Data.Profunctor.Strong ((&&&))
 import Data.Tuple (Tuple)
 
 infixl 8 viewOn as ^.
@@ -32,6 +32,13 @@ viewOn s l = view l s
 to :: forall r s t a b. (s -> a) -> Fold r s t a b
 to f p = Forget (unwrap p <<< f)
 
+-- | Combine two getters.
+takeBoth :: forall s t a b c d. Getter s t a b -> Getter s t c d -> Getter s t (Tuple a c) (Tuple b d)
+takeBoth l r a = cmps (l (Forget id)) (r (Forget id))
+  where
+    cmps :: Forget a s t -> Forget c s t -> Forget (Tuple a c) s t
+    cmps (Forget f) (Forget g) = Forget (f &&& g)
+
 -- | View the focus of a `Getter` in the state of a monad.
 use :: forall s t a b m. MonadState s m => Getter s t a b -> m a
 use p = gets (_ ^. p)

test/Main.purs

@@ -1,12 +1,13 @@
 module Test.Main where
 
 import Prelude
+
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, logShow)
 import Control.Monad.State (evalState, get)
 import Data.Distributive (class Distributive)
 import Data.Either (Either(..))
-import Data.Lens (view, traversed, _1, _2, _Just, _Left, lens, collectOf)
+import Data.Lens (Getter', _1, _2, _Just, _Left, collectOf, lens, takeBoth, traversed, view)
 import Data.Lens.Fold ((^?))
 import Data.Lens.Fold.Partial ((^?!), (^@?!))
 import Data.Lens.Grate (Grate, cloneGrate, grate, zipWithOf)
@@ -28,6 +29,9 @@ foo = prop (SProxy :: SProxy "foo")
 bar :: forall a b r. Lens { bar :: a | r } { bar :: b | r } a b
 bar = prop (SProxy :: SProxy "bar")
 
+barAndFoo :: forall a b r. Getter' { bar :: a, foo :: b | r } (Tuple a b)
+barAndFoo = takeBoth bar foo
+
 type Foo a = { foo :: Maybe { bar :: Array a } }
 
 doc :: Foo String
@@ -83,6 +87,7 @@ summing = zipWithOf (cloneGrate aGrateExample) (+)
 main :: forall e. Eff (console :: CONSOLE | e) Unit
 main = do
   logShow $ view bars doc
+  logShow $ view barAndFoo { bar: "bar", foo: "foo" }
   logShow $ doc2 ^? _1bars
   logShow $ unsafePartial $ doc2 ^?! _1bars
   logShow $ unsafePartial $ Tuple 0 1 ^@?! i_2