Merge pull request #13 from purescript-contrib/refracting

Add Coproduct prisms, split up Data.Lens.Common

Author: garyb

bower.json

@@ -1,9 +1,5 @@
 {
   "name": "purescript-profunctor-lenses",
-  "version": "1.0.0",
-  "moduleType": [
-    "node"
-  ],
   "ignore": [
     "**/.*",
     "node_modules",
@@ -12,13 +8,15 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/paf31/purescript-profunctor-lenses.git"
+    "url": "git://github.com/purescript-contrib/purescript-profunctor-lenses.git"
   },
   "devDependencies": {
     "purescript-console": "^0.1.0"
   },
   "dependencies": {
     "purescript-const": "~0.5.0",
+    "purescript-coproducts": "~0.4.0",
+    "purescript-functors": "~0.1.0",
     "purescript-identity": "~0.4.0",
     "purescript-lists": "~0.7.0",
     "purescript-maps": "~0.5.2",

src/Data/Lens/Common.purs

@@ -1,44 +1,15 @@
 -- | This module defines common lenses and prisms.
 
-module Data.Lens.Common where
-
-import Prelude (Unit(), unit, const, ($), (<<<))
-
-import Data.Either (Either(..), either)
-import Data.Lens.Internal.Void (Void(), absurd)
-import Data.Lens.Lens (Lens(), LensP(), lens)
-import Data.Lens.Prism (Prism(), prism)
-import Data.Maybe (Maybe(..), maybe)
-import Data.Tuple (Tuple(..))
-
--- | Prism for the `Nothing` constructor of `Maybe`.
-_Nothing :: forall a b. Prism (Maybe a) (Maybe b) Unit Unit
-_Nothing = prism (const Nothing) $ maybe (Right unit) (const $ Left Nothing)
-
--- | Prism for the `Just` constructor of `Maybe`.
-_Just :: forall a b. Prism (Maybe a) (Maybe b) a b
-_Just = prism Just $ maybe (Left Nothing) Right
-
--- | Prism for the `Left` constructor of `Either`.
-_Left :: forall a b c. Prism (Either a c) (Either b c) a b
-_Left = prism Left $ either Right (Left <<< Right)
-
--- | Prism for the `Right` constructor of `Either`.
-_Right :: forall a b c. Prism (Either c a) (Either c b) a b
-_Right = prism Right $ either (Left <<< Left) Right
-
--- | Lens for the first component of a `Tuple`.
-_1 :: forall a b c. Lens (Tuple a c) (Tuple b c) a b
-_1 = lens (\(Tuple a _) -> a) \(Tuple _ c) b -> Tuple b c
-
--- | Lens for the second component of a `Tuple`.
-_2 :: forall a b c. Lens (Tuple c a) (Tuple c b) a b
-_2 = lens (\(Tuple _ a) -> a) \(Tuple c _) b -> Tuple c b
-
--- | There is a `Unit` in everything.
-united :: forall a. LensP a Unit
-united = lens (const unit) const
-
--- | There is everything in `Void`.
-devoid :: forall a. LensP Void a
-devoid = lens absurd const
+module Data.Lens.Common
+  ( module Data.Lens.Lens.Tuple
+  , module Data.Lens.Lens.Unit
+  , module Data.Lens.Lens.Void
+  , module Data.Lens.Prism.Either
+  , module Data.Lens.Prism.Maybe
+  ) where
+
+import Data.Lens.Lens.Tuple
+import Data.Lens.Lens.Unit
+import Data.Lens.Lens.Void
+import Data.Lens.Prism.Either
+import Data.Lens.Prism.Maybe

src/Data/Lens/Iso/Coproduct.purs

@@ -0,0 +1,9 @@
+module Data.Lens.Iso.Coproduct where
+
+import Data.Functor.Coproduct (Coproduct(..), runCoproduct)
+import Data.Either (Either())
+
+import Data.Lens.Iso (Iso(), iso)
+
+_Coproduct :: forall f g h i a b. Iso (Coproduct f g a) (Coproduct h i b) (Either (f a) (g a)) (Either (h b) (i b))
+_Coproduct = iso runCoproduct Coproduct

src/Data/Lens/Iso/Product.purs

@@ -0,0 +1,9 @@
+module Data.Lens.Iso.Product where
+
+import Data.Functor.Product (Product(..), runProduct)
+import Data.Tuple (Tuple())
+
+import Data.Lens.Iso (Iso(), iso)
+
+_Product :: forall f g h i a b. Iso (Product f g a) (Product h i b) (Tuple (f a) (g a)) (Tuple (h b) (i b))
+_Product = iso runProduct Product

src/Data/Lens/Lens/Product.purs

@@ -0,0 +1,17 @@
+module Data.Lens.Lens.Product where
+
+import Prelude ((<<<))
+
+import Data.Functor.Product (Product())
+
+import Data.Lens.Iso.Product (_Product)
+import Data.Lens.Lens (Lens())
+import Data.Lens.Lens.Tuple as T
+
+-- | Lens for the `left` of a `Product`.
+_1 :: forall f g h a. Lens (Product f g a) (Product h g a) (f a) (h a)
+_1 = _Product <<< T._1
+
+-- | Lens for the `right` of a `Product`.
+_2 :: forall f g h a. Lens (Product f g a) (Product f h a) (g a) (h a)
+_2 = _Product <<< T._2

src/Data/Lens/Lens/Tuple.purs

@@ -0,0 +1,13 @@
+module Data.Lens.Lens.Tuple where
+
+import Data.Tuple (Tuple(..))
+
+import Data.Lens.Lens (Lens(), lens)
+
+-- | Lens for the first component of a `Tuple`.
+_1 :: forall a b c. Lens (Tuple a c) (Tuple b c) a b
+_1 = lens (\(Tuple a _) -> a) \(Tuple _ c) b -> Tuple b c
+
+-- | Lens for the second component of a `Tuple`.
+_2 :: forall a b c. Lens (Tuple c a) (Tuple c b) a b
+_2 = lens (\(Tuple _ a) -> a) \(Tuple c _) b -> Tuple c b

src/Data/Lens/Lens/Unit.purs

@@ -0,0 +1,9 @@
+module Data.Lens.Lens.Unit where
+
+import Prelude
+
+import Data.Lens.Lens (LensP(), lens)
+
+-- | There is a `Unit` in everything.
+united :: forall a. LensP a Unit
+united = lens (const unit) const

src/Data/Lens/Lens/Void.purs

@@ -0,0 +1,11 @@
+module Data.Lens.Lens.Void where
+
+import Prelude (const)
+
+import Data.Lens.Internal.Void (Void(), absurd)
+
+import Data.Lens.Lens (LensP(), lens)
+
+-- | There is everything in `Void`.
+devoid :: forall a. LensP Void a
+devoid = lens absurd const

src/Data/Lens/Prism/Coproduct.purs

@@ -0,0 +1,17 @@
+module Data.Lens.Prism.Coproduct where
+
+import Prelude ((<<<))
+
+import Data.Functor.Coproduct (Coproduct())
+
+import Data.Lens.Iso.Coproduct (_Coproduct)
+import Data.Lens.Prism (Prism())
+import Data.Lens.Prism.Either as E
+
+-- | Prism for the `left` of a `Coproduct`.
+_Left :: forall f g h a. Prism (Coproduct f g a) (Coproduct h g a) (f a) (h a)
+_Left = _Coproduct <<< E._Left
+
+-- | Prism for the `right` of a `Coproduct`.
+_Right :: forall f g h a. Prism (Coproduct f g a) (Coproduct f h a) (g a) (h a)
+_Right = _Coproduct <<< E._Right

src/Data/Lens/Prism/Either.purs

@@ -0,0 +1,15 @@
+module Data.Lens.Prism.Either where
+
+import Prelude
+
+import Data.Either (Either(..), either)
+
+import Data.Lens.Prism (Prism(), prism)
+
+-- | Prism for the `Left` constructor of `Either`.
+_Left :: forall a b c. Prism (Either a c) (Either b c) a b
+_Left = prism Left $ either Right (Left <<< Right)
+
+-- | Prism for the `Right` constructor of `Either`.
+_Right :: forall a b c. Prism (Either c a) (Either c b) a b
+_Right = prism Right $ either (Left <<< Left) Right