Merge pull request #28 from purescript/bump

Prepare for 2.0 release

Author: garyb

bower.json

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

src/Data/Monoid/Additive.purs

@@ -1,21 +1,13 @@
 module Data.Monoid.Additive where
 
-import Control.Applicative (class Applicative)
-import Control.Apply (class Apply)
-import Control.Bind (class Bind)
+import Prelude
+
 import Control.Comonad (class Comonad)
 import Control.Extend (class Extend)
-import Control.Monad (class Monad)
 
-import Data.Bounded (class Bounded, top, bottom)
-import Data.Eq (class Eq, (==))
-import Data.Functor (class Functor)
 import Data.Functor.Invariant (class Invariant)
 import Data.Monoid (class Monoid)
-import Data.Ord (class Ord, compare)
-import Data.Semigroup (class Semigroup, (<>))
-import Data.Semiring (class Semiring, (+), zero)
-import Data.Show (class Show, show)
+import Data.Newtype (class Newtype, unwrap)
 
 -- | Monoid and semigroup for semirings under addition.
 -- |
@@ -25,18 +17,13 @@ import Data.Show (class Show, show)
 -- | ```
 newtype Additive a = Additive a
 
-runAdditive :: forall a. Additive a -> a
-runAdditive (Additive x) = x
+derive instance newtypeAdditive :: Newtype (Additive a) _
 
-instance eqAdditive :: Eq a => Eq (Additive a) where
-  eq (Additive x) (Additive y) = x == y
+derive newtype instance eqAdditive :: Eq a => Eq (Additive a)
 
-instance ordAdditive :: Ord a => Ord (Additive a) where
-  compare (Additive x) (Additive y) = compare x y
+derive newtype instance ordAdditive :: Ord a => Ord (Additive a)
 
-instance boundedAdditive :: Bounded a => Bounded (Additive a) where
-  top = Additive top
-  bottom = Additive bottom
+derive newtype instance boundedAdditive :: Bounded a => Bounded (Additive a)
 
 instance functorAdditive :: Functor Additive where
   map f (Additive x) = Additive (f x)
@@ -59,7 +46,7 @@ instance extendAdditive :: Extend Additive where
   extend f x = Additive (f x)
 
 instance comonadAdditive :: Comonad Additive where
-  extract = runAdditive
+  extract = unwrap
 
 instance showAdditive :: Show a => Show (Additive a) where
   show (Additive a) = "(Additive " <> show a <> ")"

src/Data/Monoid/Conj.purs

@@ -1,22 +1,14 @@
 module Data.Monoid.Conj where
 
-import Control.Applicative (class Applicative)
-import Control.Apply (class Apply)
-import Control.Bind (class Bind)
+import Prelude
+
 import Control.Comonad (class Comonad)
 import Control.Extend (class Extend)
-import Control.Monad (class Monad)
 
-import Data.HeytingAlgebra (class HeytingAlgebra, conj, disj, ff, tt)
-import Data.Bounded (class Bounded, top, bottom)
-import Data.Eq (class Eq, (==))
-import Data.Functor (class Functor)
 import Data.Functor.Invariant (class Invariant)
+import Data.HeytingAlgebra (ff, tt)
 import Data.Monoid (class Monoid)
-import Data.Ord (class Ord, compare)
-import Data.Semigroup (class Semigroup, (<>))
-import Data.Semiring (class Semiring)
-import Data.Show (class Show, show)
+import Data.Newtype (class Newtype, unwrap)
 
 -- | Monoid under conjuntion.
 -- |
@@ -26,18 +18,13 @@ import Data.Show (class Show, show)
 -- | ```
 newtype Conj a = Conj a
 
-runConj :: forall a. Conj a -> a
-runConj (Conj x) = x
+derive instance newtypeConj :: Newtype (Conj a) _
 
-instance eqConj :: Eq a => Eq (Conj a) where
-  eq (Conj x) (Conj y) = x == y
+derive newtype instance eqConj :: Eq a => Eq (Conj a)
 
-instance ordConj :: Ord a => Ord (Conj a) where
-  compare (Conj x) (Conj y) = compare x y
+derive newtype instance ordConj :: Ord a => Ord (Conj a)
 
-instance boundedConj :: Bounded a => Bounded (Conj a) where
-  top = Conj top
-  bottom = Conj bottom
+derive newtype instance boundedConj :: Bounded a => Bounded (Conj a)
 
 instance functorConj :: Functor Conj where
   map f (Conj x) = Conj (f x)
@@ -60,7 +47,7 @@ instance extendConj :: Extend Conj where
   extend f x = Conj (f x)
 
 instance comonadConj :: Comonad Conj where
-  extract = runConj
+  extract = unwrap
 
 instance showConj :: (Show a) => Show (Conj a) where
   show (Conj a) = "(Conj " <> show a <> ")"

src/Data/Monoid/Disj.purs

@@ -1,21 +1,14 @@
 module Data.Monoid.Disj where
 
-import Control.Applicative (class Applicative)
-import Control.Apply (class Apply)
-import Control.Bind (class Bind)
+import Prelude
+
 import Control.Comonad (class Comonad)
 import Control.Extend (class Extend)
-import Control.Monad (class Monad)
 
-import Data.HeytingAlgebra (class HeytingAlgebra, conj, disj, ff, tt)
-import Data.Bounded (class Bounded, top, bottom)
-import Data.Eq (class Eq, (==))
-import Data.Functor (class Functor)
+import Data.Functor.Invariant (class Invariant)
+import Data.HeytingAlgebra (ff, tt)
 import Data.Monoid (class Monoid)
-import Data.Ord (class Ord, compare)
-import Data.Semigroup (class Semigroup, (<>))
-import Data.Semiring (class Semiring)
-import Data.Show (class Show, show)
+import Data.Newtype (class Newtype, unwrap)
 
 -- | Monoid under disjuntion.
 -- |
@@ -25,22 +18,20 @@ import Data.Show (class Show, show)
 -- | ```
 newtype Disj a = Disj a
 
-runDisj :: forall a. Disj a -> a
-runDisj (Disj x) = x
+derive instance newtypeDisj :: Newtype (Disj a) _
 
-instance eqDisj :: Eq a => Eq (Disj a) where
-  eq (Disj x) (Disj y) = x == y
+derive newtype instance eqDisj :: Eq a => Eq (Disj a)
 
-instance ordDisj :: Ord a => Ord (Disj a) where
-  compare (Disj x) (Disj y) = compare x y
+derive newtype instance ordDisj :: Ord a => Ord (Disj a)
 
-instance boundedDisj :: Bounded a => Bounded (Disj a) where
-  top = Disj top
-  bottom = Disj bottom
+derive newtype instance boundedDisj :: Bounded a => Bounded (Disj a)
 
 instance functorDisj :: Functor Disj where
   map f (Disj x) = Disj (f x)
 
+instance invariantDisj :: Invariant Disj where
+  imap f _ (Disj x) = Disj (f x)
+
 instance applyDisj :: Apply Disj where
   apply (Disj f) (Disj x) = Disj (f x)
 
@@ -56,7 +47,7 @@ instance extendDisj :: Extend Disj where
   extend f x = Disj (f x)
 
 instance comonadDisj :: Comonad Disj where
-  extract = runDisj
+  extract = unwrap
 
 instance showDisj :: Show a => Show (Disj a) where
   show (Disj a) = "(Disj " <> show a <> ")"

src/Data/Monoid/Dual.purs

@@ -1,20 +1,13 @@
 module Data.Monoid.Dual where
 
-import Control.Applicative (class Applicative)
-import Control.Apply (class Apply)
-import Control.Bind (class Bind)
+import Prelude
+
 import Control.Comonad (class Comonad)
 import Control.Extend (class Extend)
-import Control.Monad (class Monad)
 
-import Data.Bounded (class Bounded, top, bottom)
-import Data.Eq (class Eq, (==))
-import Data.Functor (class Functor)
 import Data.Functor.Invariant (class Invariant)
 import Data.Monoid (class Monoid, mempty)
-import Data.Ord (class Ord, compare)
-import Data.Semigroup (class Semigroup, (<>))
-import Data.Show (class Show, show)
+import Data.Newtype (class Newtype, unwrap)
 
 -- | The dual of a monoid.
 -- |
@@ -24,18 +17,13 @@ import Data.Show (class Show, show)
 -- | ```
 newtype Dual a = Dual a
 
-runDual :: forall a. Dual a -> a
-runDual (Dual x) = x
+derive instance newtypeDual :: Newtype (Dual a) _
 
-instance eqDual :: Eq a => Eq (Dual a) where
-  eq (Dual x) (Dual y) = x == y
+derive newtype instance eqDual :: Eq a => Eq (Dual a)
 
-instance ordDual :: Ord a => Ord (Dual a) where
-  compare (Dual x) (Dual y) = compare x y
+derive newtype instance ordDual :: Ord a => Ord (Dual a)
 
-instance boundedDual :: Bounded a => Bounded (Dual a) where
-  top = Dual top
-  bottom = Dual bottom
+derive newtype instance boundedDual :: Bounded a => Bounded (Dual a)
 
 instance functorDual :: Functor Dual where
   map f (Dual x) = Dual (f x)
@@ -58,7 +46,7 @@ instance extendDual :: Extend Dual where
   extend f x = Dual (f x)
 
 instance comonadDual :: Comonad Dual where
-  extract = runDual
+  extract = unwrap
 
 instance showDual :: Show a => Show (Dual a) where
   show (Dual a) = "(Dual " <> show a <> ")"

src/Data/Monoid/Endo.purs

@@ -1,9 +1,10 @@
 module Data.Monoid.Endo where
 
-import Data.Function (id, (<<<))
+import Prelude
+
 import Data.Functor.Invariant (class Invariant)
 import Data.Monoid (class Monoid)
-import Data.Semigroup (class Semigroup)
+import Data.Newtype (class Newtype)
 
 -- | Monoid of endomorphisms under composition.
 -- |
@@ -14,8 +15,7 @@ import Data.Semigroup (class Semigroup)
 -- | ```
 newtype Endo a = Endo (a -> a)
 
-runEndo :: forall a. Endo a -> a -> a
-runEndo (Endo f) = f
+derive instance newtypeEndo :: Newtype (Endo a) _
 
 instance invariantEndo :: Invariant Endo where
   imap ab ba (Endo f) = Endo (ab <<< f <<< ba)

src/Data/Monoid/Multiplicative.purs

@@ -1,21 +1,13 @@
 module Data.Monoid.Multiplicative where
 
-import Control.Applicative (class Applicative)
-import Control.Apply (class Apply)
-import Control.Bind (class Bind)
+import Prelude
+
 import Control.Comonad (class Comonad)
 import Control.Extend (class Extend)
-import Control.Monad (class Monad)
 
-import Data.Bounded (class Bounded, top, bottom)
-import Data.Eq (class Eq, (==))
-import Data.Functor (class Functor)
 import Data.Functor.Invariant (class Invariant)
 import Data.Monoid (class Monoid)
-import Data.Ord (class Ord, compare)
-import Data.Semigroup (class Semigroup, (<>))
-import Data.Semiring (class Semiring, (*), one)
-import Data.Show (class Show, show)
+import Data.Newtype (class Newtype, unwrap)
 
 -- | Monoid and semigroup for semirings under multiplication.
 -- |
@@ -25,18 +17,13 @@ import Data.Show (class Show, show)
 -- | ```
 newtype Multiplicative a = Multiplicative a
 
-runMultiplicative :: forall a. Multiplicative a -> a
-runMultiplicative (Multiplicative x) = x
+derive instance newtypeMultiplicative :: Newtype (Multiplicative a) _
 
-instance eqMultiplicative :: (Eq a) => Eq (Multiplicative a) where
-  eq (Multiplicative x) (Multiplicative y) = x == y
+derive newtype instance eqMultiplicative :: Eq a => Eq (Multiplicative a)
 
-instance ordMultiplicative :: (Ord a) => Ord (Multiplicative a) where
-  compare (Multiplicative x) (Multiplicative y) = compare x y
+derive newtype instance ordMultiplicative :: Ord a => Ord (Multiplicative a)
 
-instance boundedMultiplicative :: Bounded a => Bounded (Multiplicative a) where
-  top = Multiplicative top
-  bottom = Multiplicative bottom
+derive newtype instance boundedMultiplicative :: Bounded a => Bounded (Multiplicative a)
 
 instance functorMultiplicative :: Functor Multiplicative where
   map f (Multiplicative x) = Multiplicative (f x)
@@ -59,7 +46,7 @@ instance extendMultiplicative :: Extend Multiplicative where
   extend f x = Multiplicative (f x)
 
 instance comonadMultiplicative :: Comonad Multiplicative where
-  extract = runMultiplicative
+  extract = unwrap
 
 instance showMultiplicative :: (Show a) => Show (Multiplicative a) where
   show (Multiplicative a) = "(Multiplicative " <> show a <> ")"