Merge pull request #51 from purescript/bump

Prepare for 2.0 release

Author: garyb

bower.json

@@ -17,13 +17,13 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-bifunctors": "^1.0.0",
-    "purescript-maybe": "^1.0.0"
+    "purescript-bifunctors": "^2.0.0",
+    "purescript-maybe": "^2.0.0"
   },
   "devDependencies": {
-    "purescript-assert": "^1.0.0",
-    "purescript-console": "^1.0.0",
-    "purescript-integers": "^1.0.0",
+    "purescript-assert": "^2.0.0",
+    "purescript-console": "^2.0.0",
+    "purescript-integers": "^2.0.0",
     "purescript-math": "^2.0.0"
   }
 }

examples/Traversable.purs

@@ -1,16 +1,15 @@
 module Data.Bifoldable where
 
-import Control.Applicative (class Applicative, pure)
+import Prelude
+
 import Control.Apply (applySecond)
 
-import Data.BooleanAlgebra (class BooleanAlgebra)
-import Data.Function (id, flip, (<<<))
-import Data.Monoid (class Monoid, mempty, append, (<>))
-import Data.Monoid.Conj (Conj(..), runConj)
-import Data.Monoid.Disj (Disj(..), runDisj)
-import Data.Monoid.Dual (Dual(..), runDual)
-import Data.Monoid.Endo (Endo(..), runEndo)
-import Data.Unit (Unit, unit)
+import Data.Monoid (class Monoid, mempty)
+import Data.Monoid.Conj (Conj(..))
+import Data.Monoid.Disj (Disj(..))
+import Data.Monoid.Dual (Dual(..))
+import Data.Monoid.Endo (Endo(..))
+import Data.Newtype (unwrap)
 
 -- | `Bifoldable` represents data structures with two type arguments which can be
 -- | folded.
@@ -46,8 +45,7 @@ bifoldrDefault
   -> c
   -> p a b
   -> c
-bifoldrDefault f g z p =
-  runEndo (bifoldMap (Endo <<< f) (Endo <<< g) p) z
+bifoldrDefault f g z p = unwrap (bifoldMap (Endo <<< f) (Endo <<< g) p) z
 
 -- | A default implementation of `bifoldl` using `bifoldMap`.
 -- |
@@ -62,8 +60,8 @@ bifoldlDefault
   -> p a b
   -> c
 bifoldlDefault f g z p =
-  runEndo
-    (runDual
+  unwrap
+    (unwrap
       (bifoldMap (Dual <<< Endo <<< flip f) (Dual <<< Endo <<< flip g) p))
     z
 
@@ -136,7 +134,7 @@ biany
   -> (b -> c)
   -> t a b
   -> c
-biany p q = runDisj <<< bifoldMap (Disj <<< p) (Disj <<< q)
+biany p q = unwrap <<< bifoldMap (Disj <<< p) (Disj <<< q)
 
 -- | Test whether a predicate holds at all positions in a data structure.
 biall
@@ -146,4 +144,4 @@ biall
   -> (b -> c)
   -> t a b
   -> c
-biall p q = runConj <<< bifoldMap (Conj <<< p) (Conj <<< q)
+biall p q = unwrap <<< bifoldMap (Conj <<< p) (Conj <<< q)

examples/Tree.purs

@@ -6,8 +6,7 @@ module Data.Bitraversable
   , module Data.Bifoldable
   ) where
 
-import Control.Applicative (class Applicative)
-import Control.Category (id)
+import Prelude
 
 import Data.Bifoldable (class Bifoldable, biall, biany, bifold, bifoldMap, bifoldMapDefaultL, bifoldMapDefaultR, bifoldl, bifoldlDefault, bifoldr, bifoldrDefault, bifor_, bisequence_, bitraverse_)
 import Data.Bifunctor (class Bifunctor, bimap)

src/Data/Bifoldable.purs

@@ -22,27 +22,21 @@ module Data.Foldable
   , minimumBy
   ) where
 
-import Control.Applicative (class Applicative, pure)
-import Control.Apply ((*>))
+import Prelude
+
 import Control.Plus (class Plus, alt, empty)
 
-import Data.BooleanAlgebra (class BooleanAlgebra, not)
-import Data.Eq (class Eq, (==))
-import Data.Function (id, flip, (<<<))
 import Data.Maybe (Maybe(..))
 import Data.Maybe.First (First(..))
 import Data.Maybe.Last (Last(..))
-import Data.Monoid (class Monoid, mempty, (<>))
+import Data.Monoid (class Monoid, mempty)
 import Data.Monoid.Additive (Additive(..))
-import Data.Monoid.Conj (Conj(..), runConj)
-import Data.Monoid.Disj (Disj(..), runDisj)
-import Data.Monoid.Dual (Dual(..), runDual)
-import Data.Monoid.Endo (Endo(..), runEndo)
+import Data.Monoid.Conj (Conj(..))
+import Data.Monoid.Disj (Disj(..))
+import Data.Monoid.Dual (Dual(..))
+import Data.Monoid.Endo (Endo(..))
 import Data.Monoid.Multiplicative (Multiplicative(..))
-import Data.Ord (class Ord, compare)
-import Data.Ordering (Ordering(..))
-import Data.Semiring (class Semiring, one, (*), zero, (+))
-import Data.Unit (Unit, unit)
+import Data.Newtype (alaF, unwrap)
 
 -- | `Foldable` represents data structures which can be _folded_.
 -- |
@@ -76,7 +70,7 @@ foldrDefault
   -> b
   -> f a
   -> b
-foldrDefault c u xs = runEndo (foldMap (Endo <<< c) xs) u
+foldrDefault c u xs = unwrap (foldMap (Endo <<< c) xs) u
 
 -- | A default implementation of `foldl` using `foldMap`.
 -- |
@@ -89,8 +83,7 @@ foldlDefault
    -> b
    -> f a
    -> b
-foldlDefault c u xs =
-  runEndo (runDual (foldMap (Dual <<< Endo <<< flip c) xs)) u
+foldlDefault c u xs = unwrap (unwrap (foldMap (Dual <<< Endo <<< flip c) xs)) u
 
 -- | A default implementation of `foldMap` using `foldr`.
 -- |
@@ -234,24 +227,24 @@ intercalate sep xs = (foldl go { init: true, acc: mempty } xs).acc
 -- | The conjunction of all the values in a data structure. When specialized
 -- | to `Boolean`, this function will test whether all of the values in a data
 -- | structure are `true`.
-and :: forall a f. (Foldable f, BooleanAlgebra a) => f a -> a
+and :: forall a f. (Foldable f, HeytingAlgebra a) => f a -> a
 and = all id
 
 -- | The disjunction of all the values in a data structure. When specialized
 -- | to `Boolean`, this function will test whether any of the values in a data
 -- | structure is `true`.
-or :: forall a f. (Foldable f, BooleanAlgebra a) => f a -> a
+or :: forall a f. (Foldable f, HeytingAlgebra a) => f a -> a
 or = any id
 
 -- | `all f` is the same as `and <<< map f`; map a function over the structure,
 -- | and then get the conjunction of the results.
-all :: forall a b f. (Foldable f, BooleanAlgebra b) => (a -> b) -> f a -> b
-all p = runConj <<< foldMap (Conj <<< p)
+all :: forall a b f. (Foldable f, HeytingAlgebra b) => (a -> b) -> f a -> b
+all p = alaF Conj foldMap p
 
 -- | `any f` is the same as `or <<< map f`; map a function over the structure,
 -- | and then get the disjunction of the results.
-any :: forall a b f. (Foldable f, BooleanAlgebra b) => (a -> b) -> f a -> b
-any p = runDisj <<< foldMap (Disj <<< p)
+any :: forall a b f. (Foldable f, HeytingAlgebra b) => (a -> b) -> f a -> b
+any p = alaF Disj foldMap p
 
 -- | Find the sum of the numeric values in a data structure.
 sum :: forall a f. (Foldable f, Semiring a) => f a -> a

src/Data/Bitraversable.purs

@@ -1,7 +1,5 @@
 "use strict";
 
-// module Data.Traversable
-
 // jshint maxparams: 3
 
 exports.traverseArrayImpl = function () {

src/Data/Foldable.purs

@@ -10,12 +10,9 @@ module Data.Traversable
   , module Data.Foldable
   ) where
 
-import Control.Applicative (class Applicative, pure)
-import Control.Apply (class Apply, apply)
-import Control.Category (id)
+import Prelude
 
 import Data.Foldable (class Foldable, all, and, any, elem, find, fold, foldMap, foldMapDefaultL, foldMapDefaultR, foldl, foldlDefault, foldr, foldrDefault, for_, intercalate, maximum, maximumBy, minimum, minimumBy, notElem, oneOf, or, product, sequence_, sum, traverse_)
-import Data.Functor (class Functor, map, (<$>))
 import Data.Maybe (Maybe(..))
 import Data.Maybe.First (First(..))
 import Data.Maybe.Last (Last(..))

src/Data/Traversable.js

@@ -1,7 +1,5 @@
 "use strict";
 
-// module Test.Main
-
 exports.arrayFrom1UpTo = function (n) {
   var result = [];
   for (var i = 1; i <= n; i++) {