Bump deps for compiler/0.12

Author: LiamGoodacre

bower.json

@@ -1,7 +1,7 @@
 {
   "name": "purescript-profunctor",
   "homepage": "https://github.com/purescript/purescript-profunctor",
-  "description": "Profunctor typeclass for PureScript",
+  "description": "Profunctor type class for PureScript",
   "authors": [
     "Hardy Jones <jones3.hardy@gmail.com>",
     "Sean Chalmers <sclhiannan@gmail.com>",
@@ -22,10 +22,10 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-contravariant": "^3.0.0",
-    "purescript-distributive": "^3.0.0",
-    "purescript-either": "^3.0.0",
-    "purescript-exists": "^3.0.0",
-    "purescript-tuples": "^4.0.0"
+    "purescript-contravariant": "#compiler/0.12",
+    "purescript-distributive": "#compiler/0.12",
+    "purescript-either": "#compiler/0.12",
+    "purescript-exists": "#compiler/0.12",
+    "purescript-tuples": "#compiler/0.12"
   }
 }

package.json

@@ -5,8 +5,8 @@
     "build": "pulp build -- --censor-lib --strict"
   },
   "devDependencies": {
-    "pulp": "^10.0.4",
-    "purescript-psa": "^0.5.0-rc.1",
-    "rimraf": "^2.6.1"
+    "pulp": "^12.0.1",
+    "purescript-psa": "^0.6.0",
+    "rimraf": "^2.6.2"
   }
 }

src/Data/Profunctor.purs

@@ -17,22 +17,22 @@ import Data.Newtype (class Newtype, wrap, unwrap)
 -- |
 -- | Laws:
 -- |
--- | - Identity: `dimap id id = id`
+-- | - Identity: `dimap identity identity = identity`
 -- | - Composition: `dimap f1 g1 <<< dimap f2 g2 = dimap (f1 >>> f2) (g1 <<< g2)`
 class Profunctor p where
   dimap :: forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
 
 -- | Map a function over the (contravariant) first type argument only.
 lmap :: forall a b c p. Profunctor p => (a -> b) -> p b c -> p a c
-lmap a2b = dimap a2b id
+lmap a2b = dimap a2b identity
 
 -- | Map a function over the (covariant) second type argument only.
 rmap :: forall a b c p. Profunctor p => (b -> c) -> p a b -> p a c
-rmap b2c = dimap id b2c
+rmap b2c = dimap identity b2c
 
 -- | Lift a pure function into any `Profunctor` which is also a `Category`.
 arr :: forall a b p. Category p => Profunctor p => (a -> b) -> p a b
-arr f = rmap f id
+arr f = rmap f identity
 
 unwrapIso :: forall p t a. Profunctor p => Newtype t a => p t t -> p a a
 unwrapIso = dimap wrap unwrap

src/Data/Profunctor/Choice.purs

@@ -81,6 +81,6 @@ fanin
 fanin l r = (l +++ r) >>> join
   where
   join :: p (Either c c) c
-  join = dimap (either id id) id id
+  join = dimap (either identity identity) identity identity
 
 infixr 2 fanin as |||

src/Data/Profunctor/Costar.purs

@@ -27,7 +27,7 @@ instance semigroupoidCostar :: Extend f => Semigroupoid (Costar f) where
   compose (Costar f) (Costar g) = Costar (f =<= g)
 
 instance categoryCostar :: Comonad f => Category (Costar f) where
-  id = Costar extract
+  identity = Costar extract
 
 instance functorCostar :: Functor (Costar f a) where
   map f (Costar g) = Costar (f <<< g)
@@ -65,10 +65,10 @@ instance costrongCostar :: Functor f => Costrong (Costar f) where
 
 instance cochoiceCostar :: Applicative f => Cochoice (Costar f) where
   unleft (Costar f) =
-    let g = either id (\r -> g (pure (Right r))) <<< f
+    let g = either identity (\r -> g (pure (Right r))) <<< f
     in Costar (g <<< map Left)
   unright (Costar f) =
-    let g = either (\l -> g (pure (Left l))) id <<< f
+    let g = either (\l -> g (pure (Left l))) identity <<< f
     in Costar (g <<< map Right)
 
 instance closedCostar :: Functor f => Closed (Costar f) where

src/Data/Profunctor/Join.purs

@@ -5,7 +5,6 @@ import Prelude
 import Data.Functor.Invariant (class Invariant)
 import Data.Newtype (class Newtype)
 import Data.Profunctor (class Profunctor, dimap)
-import Data.Monoid (class Monoid)
 
 -- | Turns a `Profunctor` into a `Invariant` functor by equating the two type
 -- | arguments.
@@ -22,7 +21,7 @@ instance semigroupJoin :: Semigroupoid p => Semigroup (Join p a) where
   append (Join a) (Join b) = Join (a <<< b)
 
 instance monoidJoin :: Category p => Monoid (Join p a) where
-  mempty = Join id
+  mempty = Join identity
 
 instance invariantJoin :: Profunctor p => Invariant (Join p) where
   imap f g (Join a) = Join (dimap g f a)

src/Data/Profunctor/Split.purs

@@ -30,7 +30,7 @@ unSplit :: forall f a b r. (forall x. (a -> x) -> (x -> b) -> f x -> r) -> Split
 unSplit f (Split e) = runExists (\(SplitF g h fx) -> f g h fx) e
 
 liftSplit :: forall f a. f a -> Split f a a
-liftSplit = split id id
+liftSplit = split identity identity
 
 lowerSplit :: forall f a. Invariant f => Split f a a -> f a
 lowerSplit = unSplit (flip imap)

src/Data/Profunctor/Star.purs

@@ -29,7 +29,7 @@ instance semigroupoidStar :: Bind f => Semigroupoid (Star f) where
   compose (Star f) (Star g) = Star \x -> g x >>= f
 
 instance categoryStar :: Monad f => Category (Star f) where
-  id = Star pure
+  identity = Star pure
 
 instance functorStar :: Functor f => Functor (Star f a) where
   map f (Star g) = Star (map f <<< g)

src/Data/Profunctor/Strong.purs

@@ -78,6 +78,6 @@ fanout
 fanout l r = split >>> (l *** r)
   where
   split :: p a (Tuple a a)
-  split = dimap id (\a -> Tuple a a) id
+  split = dimap identity (\a -> Tuple a a) identity
 
 infixr 3 fanout as &&&