Merge pull request #10 from purescript/bump

Prepare for 2.0 release

Author: garyb

bower.json

@@ -17,6 +17,7 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-control": "^1.0.0"
+    "purescript-control": "^2.0.0",
+    "purescript-newtype": "^1.0.0"
   }
 }

src/Data/Bifunctor/Clown.purs

@@ -1,26 +1,30 @@
 module Data.Bifunctor.Clown where
 
-import Control.Applicative (class Applicative, pure)
-import Control.Apply (class Apply, (<*>))
+import Prelude
+
 import Control.Biapplicative (class Biapplicative)
 import Control.Biapply (class Biapply)
-import Control.Semigroupoid ((<<<))
 
 import Data.Bifunctor (class Bifunctor)
-import Data.Functor (class Functor, map)
+import Data.Newtype (class Newtype)
 
 -- | Make a `Functor` over the first argument of a `Bifunctor`
 newtype Clown f a b = Clown (f a)
 
--- | Remove the `Clown` constructor.
-runClown :: forall f a b. Clown f a b -> f a
-runClown (Clown fa) = fa
+derive instance newtypeClown :: Newtype (Clown f a b) _
 
-instance bifunctorClown :: Functor f => Bifunctor (Clown f) where
-  bimap f _ = Clown <<< map f <<< runClown
+derive newtype instance eqClown :: Eq (f a) => Eq (Clown f a b)
+
+derive newtype instance ordClown :: Ord (f a) => Ord (Clown f a b)
+
+instance showClown :: Show (f a) => Show (Clown f a b) where
+  show (Clown x) = "(Clown " <> show x <> ")"
 
 instance functorClown :: Functor (Clown f a) where
-  map _ = Clown <<< runClown
+  map _ (Clown a) = Clown a
+
+instance bifunctorClown :: Functor f => Bifunctor (Clown f) where
+  bimap f _ (Clown a) = Clown (map f a)
 
 instance biapplyClown :: Apply f => Biapply (Clown f) where
   biapply (Clown fg) (Clown xy) = Clown (fg <*> xy)

src/Data/Bifunctor/Flip.purs

@@ -1,24 +1,30 @@
 module Data.Bifunctor.Flip where
 
+import Prelude
+
 import Control.Biapplicative (class Biapplicative, bipure)
 import Control.Biapply (class Biapply, (<<*>>))
-import Control.Semigroupoid ((<<<))
 
 import Data.Bifunctor (class Bifunctor, bimap, lmap)
-import Data.Functor (class Functor)
+import Data.Newtype (class Newtype)
 
 -- | Flips the order of the type arguments of a `Bifunctor`.
 newtype Flip p a b = Flip (p b a)
 
--- | Remove the `Flip` constructor.
-runFlip :: forall p a b. Flip p a b -> p b a
-runFlip (Flip pba) = pba
+derive instance newtypeFlip :: Newtype (Flip p a b) _
+
+derive newtype instance eqFlip :: Eq (p b a) => Eq (Flip p a b)
+
+derive newtype instance ordFlip :: Ord (p b a) => Ord (Flip p a b)
+
+instance showFlip :: Show (p a b) => Show (Flip p b a) where
+  show (Flip x) = "(Flip " <> show x <> ")"
 
 instance functorFlip :: Bifunctor p => Functor (Flip p a) where
-  map f = Flip <<< lmap f <<< runFlip
+  map f (Flip a) = Flip (lmap f a)
 
 instance bifunctorFlip :: Bifunctor p => Bifunctor (Flip p) where
-  bimap f g = Flip <<< bimap g f <<< runFlip
+  bimap f g (Flip a) = Flip (bimap g f a)
 
 instance biapplyFlip :: Biapply p => Biapply (Flip p) where
   biapply (Flip fg) (Flip xy) = Flip (fg <<*>> xy)

src/Data/Bifunctor/Join.purs

@@ -1,23 +1,27 @@
 module Data.Bifunctor.Join where
 
-import Control.Applicative (class Applicative)
-import Control.Apply (class Apply)
+import Prelude
+
 import Control.Biapplicative (class Biapplicative, bipure)
 import Control.Biapply (class Biapply, (<<*>>))
-import Control.Semigroupoid ((<<<))
 
 import Data.Bifunctor (class Bifunctor, bimap)
-import Data.Functor (class Functor, (<$>))
+import Data.Newtype (class Newtype)
 
 -- | Turns a `Bifunctor` into a `Functor` by equating the two type arguments.
 newtype Join p a = Join (p a a)
 
--- | Remove the `Join` constructor.
-runJoin :: forall p a. Join p a -> p a a
-runJoin (Join paa) = paa
+derive instance newtypeJoin :: Newtype (Join p a) _
+
+derive newtype instance eqJoin :: Eq (p a a) => Eq (Join p a)
+
+derive newtype instance ordJoin :: Ord (p a a) => Ord (Join p a)
+
+instance showJoin :: Show (p a a) => Show (Join p a) where
+  show (Join x) = "(Join " <> show x <> ")"
 
 instance bifunctorJoin :: Bifunctor p => Functor (Join p) where
-  map f = Join <$> bimap f f <<< runJoin
+  map f (Join a) = Join (bimap f f a)
 
 instance biapplyJoin :: Biapply p => Apply (Join p) where
   apply (Join f) (Join a) = Join (f <<*>> a)

src/Data/Bifunctor/Joker.purs

@@ -1,29 +1,33 @@
 module Data.Bifunctor.Joker where
 
-import Control.Applicative (class Applicative, pure)
-import Control.Apply (class Apply, (<*>))
+import Prelude
+
 import Control.Biapplicative (class Biapplicative)
 import Control.Biapply (class Biapply)
-import Control.Semigroupoid ((<<<))
 
 import Data.Bifunctor (class Bifunctor)
-import Data.Functor (class Functor, map)
+import Data.Newtype (class Newtype)
 
 -- | Make a `Functor` over the second argument of a `Bifunctor`
 newtype Joker g a b = Joker (g b)
 
--- | Remove the `Joker` constructor.
-runJoker :: forall g a b. Joker g a b -> g b
-runJoker (Joker gb) = gb
+derive instance newtypeJoker :: Newtype (Joker g a b) _
+
+derive newtype instance eqJoker :: Eq (g b) => Eq (Joker g a b)
+
+derive newtype instance ordJoker :: Ord (g b) => Ord (Joker g a b)
+
+instance showJoker :: Show (g b) => Show (Joker g a b) where
+  show (Joker x) = "(Joker " <> show x <> ")"
 
-instance functorJoker :: (Functor g) => Functor (Joker g a) where
-  map g = Joker <<< map g <<< runJoker
+instance functorJoker :: Functor g => Functor (Joker g a) where
+  map g (Joker a) = Joker (map g a)
 
-instance bifunctorJoker :: (Functor g) => Bifunctor (Joker g) where
-  bimap _ g = Joker <<< map g <<< runJoker
+instance bifunctorJoker :: Functor g => Bifunctor (Joker g) where
+  bimap _ g (Joker a) = Joker (map g a)
 
-instance biapplyJoker :: (Apply g) => Biapply (Joker g) where
+instance biapplyJoker :: Apply g => Biapply (Joker g) where
   biapply (Joker fg) (Joker xy) = Joker (fg <*> xy)
 
-instance biapplicativeJoker :: (Applicative g) => Biapplicative (Joker g) where
+instance biapplicativeJoker :: Applicative g => Biapplicative (Joker g) where
   bipure _ b = Joker (pure b)

src/Data/Bifunctor/Product.purs

@@ -1,18 +1,27 @@
 module Data.Bifunctor.Product where
 
+import Prelude
+
 import Control.Biapplicative (class Biapplicative, bipure)
 import Control.Biapply (class Biapply, biapply)
 
 import Data.Bifunctor (class Bifunctor, bimap)
 
 -- | The product of two `Bifunctor`s.
-data Product f g a b = Pair (f a b) (g a b)
+data Product f g a b = Product (f a b) (g a b)
+
+derive instance eqProduct :: (Eq (f a b), Eq (g a b)) => Eq (Product f g a b)
+
+derive instance ordProduct :: (Ord (f a b), Ord (g a b)) => Ord (Product f g a b)
+
+instance showProduct :: (Show (f a b), Show (g a b)) => Show (Product f g a b) where
+  show (Product x y) = "(Product " <> show x <> " " <> show y <> ")"
 
 instance bifunctorProduct :: (Bifunctor f, Bifunctor g) => Bifunctor (Product f g) where
-  bimap f g (Pair x y) = Pair (bimap f g x) (bimap f g y)
+  bimap f g (Product x y) = Product (bimap f g x) (bimap f g y)
 
 instance biapplyProduct :: (Biapply f, Biapply g) => Biapply (Product f g) where
-  biapply (Pair w x) (Pair y z) = Pair (biapply w y) (biapply x z)
+  biapply (Product w x) (Product y z) = Product (biapply w y) (biapply x z)
 
 instance biapplicativeProduct :: (Biapplicative f, Biapplicative g) => Biapplicative (Product f g) where
-  bipure a b = Pair (bipure a b) (bipure a b)
+  bipure a b = Product (bipure a b) (bipure a b)

src/Data/Bifunctor/Wrap.purs

@@ -1,24 +1,30 @@
 module Data.Bifunctor.Wrap where
 
+import Prelude
+
 import Control.Biapplicative (class Biapplicative, bipure)
 import Control.Biapply (class Biapply, (<<*>>))
-import Control.Semigroupoid ((<<<))
 
 import Data.Bifunctor (class Bifunctor, bimap, rmap)
-import Data.Functor (class Functor)
+import Data.Newtype (class Newtype)
 
 -- | Provides a `Functor` over the second argument of a `Bifunctor`.
 newtype Wrap p a b = Wrap (p a b)
 
--- | Remove the `Wrap` constructor.
-unwrap :: forall p a b. Wrap p a b -> p a b
-unwrap (Wrap pab) = pab
+derive instance newtypeWrap :: Newtype (Wrap p a b) _
 
-instance bifunctorWrap :: Bifunctor p => Bifunctor (Wrap p) where
-  bimap f g = Wrap <<< bimap f g <<< unwrap
+derive newtype instance eqWrap :: Eq (p a b) => Eq (Wrap p a b)
+
+derive newtype instance ordWrap :: Ord (p a b) => Ord (Wrap p a b)
+
+instance showWrap :: Show (p a b) => Show (Wrap p a b) where
+  show (Wrap x) = "(Wrap " <> show x <> ")"
 
 instance functorWrap :: Bifunctor p => Functor (Wrap p a) where
-  map f = Wrap <<< rmap f <<< unwrap
+  map f (Wrap a) = Wrap (rmap f a)
+
+instance bifunctorWrap :: Bifunctor p => Bifunctor (Wrap p) where
+  bimap f g (Wrap a) = Wrap (bimap f g a)
 
 instance biapplyWrap :: Biapply p => Biapply (Wrap p) where
   biapply (Wrap fg) (Wrap xy) = Wrap (fg <<*>> xy)