Updates for 0.12

Author: garyb

bower.json

@@ -17,14 +17,14 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-bifunctors": "^3.0.0",
-    "purescript-maybe": "^3.0.0",
-    "purescript-orders": "^3.0.0"
+    "purescript-bifunctors": "#compiler/0.12",
+    "purescript-maybe": "#compiler/0.12",
+    "purescript-orders": "#compiler/0.12"
   },
   "devDependencies": {
-    "purescript-assert": "^3.0.0",
-    "purescript-console": "^3.0.0",
-    "purescript-integers": "^3.0.0",
-    "purescript-math": "^2.0.0"
+    "purescript-assert": "#compiler/0.12",
+    "purescript-console": "#compiler/0.12",
+    "purescript-integers": "#compiler/0.12",
+    "purescript-math": "#compiler/0.12"
   }
 }

src/Data/Bifoldable.purs

@@ -3,8 +3,6 @@ module Data.Bifoldable where
 import Prelude
 
 import Control.Apply (applySecond)
-
-import Data.Monoid (class Monoid, mempty)
 import Data.Monoid.Conj (Conj(..))
 import Data.Monoid.Disj (Disj(..))
 import Data.Monoid.Dual (Dual(..))
@@ -127,7 +125,7 @@ bifoldMapDefaultL f g = bifoldl (\m a -> m <> f a) (\m b -> m <> g b) mempty
 
 -- | Fold a data structure, accumulating values in a monoidal type.
 bifold :: forall t m. Bifoldable t => Monoid m => t m m -> m
-bifold = bifoldMap id id
+bifold = bifoldMap identity identity
 
 -- | Traverse a data structure, accumulating effects using an `Applicative` functor,
 -- | ignoring the final result.
@@ -160,7 +158,7 @@ bisequence_
   => Applicative f
   => t (f a) (f b)
   -> f Unit
-bisequence_ = bitraverse_ id id
+bisequence_ = bitraverse_ identity identity
 
 -- | Test whether a predicate holds at any position in a data structure.
 biany

src/Data/Bitraversable.purs

@@ -92,7 +92,7 @@ bisequenceDefault
   => Applicative f
   => t (f a) (f b)
   -> f (t a b)
-bisequenceDefault = bitraverse id id
+bisequenceDefault = bitraverse identity identity
 
 -- | Traverse a data structure, accumulating effects and results using an `Applicative` functor.
 bifor

src/Data/Foldable.purs

@@ -34,11 +34,9 @@ module Data.Foldable
 import Prelude
 
 import Control.Plus (class Plus, alt, empty)
-
 import Data.Maybe (Maybe(..))
 import Data.Maybe.First (First(..))
 import Data.Maybe.Last (Last(..))
-import Data.Monoid (class Monoid, mempty)
 import Data.Monoid.Additive (Additive(..))
 import Data.Monoid.Conj (Conj(..))
 import Data.Monoid.Disj (Disj(..))
@@ -173,7 +171,7 @@ instance foldableMultiplicative :: Foldable Multiplicative where
 
 -- | Fold a data structure, accumulating values in some `Monoid`.
 fold :: forall f m. Foldable f => Monoid m => f m -> m
-fold = foldMap id
+fold = foldMap identity
 
 -- | Similar to 'foldl', but the result is encapsulated in a monad.
 -- |
@@ -230,7 +228,7 @@ for_ = flip traverse_
 -- | sequence_ [ trace "Hello, ", trace " world!" ]
 -- | ```
 sequence_ :: forall a f m. Applicative m => Foldable f => f (m a) -> m Unit
-sequence_ = traverse_ id
+sequence_ = traverse_ identity
 
 -- | Combines a collection of elements using the `Alt` operation.
 oneOf :: forall f g a. Foldable f => Plus g => f (g a) -> g a
@@ -287,19 +285,19 @@ surroundMap d t f = unwrap (foldMap joined f) d
 -- | = "*1*2*3*"
 -- | ```
 surround :: forall f m. Foldable f => Semigroup m => m -> f m -> m
-surround d = surroundMap d id
+surround d = surroundMap d identity
 
 -- | 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 => HeytingAlgebra a => f a -> a
-and = all id
+and = all identity
 
 -- | 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 => HeytingAlgebra a => f a -> a
-or = any id
+or = any identity
 
 -- | `all f` is the same as `and <<< map f`; map a function over the structure,
 -- | and then get the conjunction of the results.

src/Data/FoldableWithIndex.purs

@@ -23,7 +23,6 @@ import Data.FunctorWithIndex (mapWithIndex)
 import Data.Maybe (Maybe(..))
 import Data.Maybe.First (First)
 import Data.Maybe.Last (Last)
-import Data.Monoid (class Monoid, mempty)
 import Data.Monoid.Additive (Additive)
 import Data.Monoid.Conj (Conj(..))
 import Data.Monoid.Disj (Disj(..))
@@ -32,15 +31,15 @@ import Data.Monoid.Endo (Endo(..))
 import Data.Monoid.Multiplicative (Multiplicative)
 import Data.Newtype (unwrap)
 
--- | A `Foldable` with an additional index.  
+-- | A `Foldable` with an additional index.
 -- | A `FoldableWithIndex` instance must be compatible with its `Foldable`
 -- | instance
 -- | ```purescript
 -- | foldr f = foldrWithIndex (const f)
 -- | foldl f = foldlWithIndex (const f)
 -- | foldMap f = foldMapWithIndex (const f)
 -- | ```
--- | 
+-- |
 -- | Default implementations are provided by the following functions:
 -- |
 -- | - `foldrWithIndexDefault`
@@ -156,9 +155,9 @@ instance foldableWithIndexMultiplicative :: FoldableWithIndex Unit Multiplicativ
   foldMapWithIndex f = foldMap $ f unit
 
 
--- | Similar to 'foldlWithIndex', but the result is encapsulated in a monad. 
+-- | Similar to 'foldlWithIndex', but the result is encapsulated in a monad.
 -- |
--- | Note: this function is not generally stack-safe, e.g., for monads which 
+-- | Note: this function is not generally stack-safe, e.g., for monads which
 -- | build up thunks a la `Eff`.
 foldWithIndexM
   :: forall i f m a b

src/Data/FunctorWithIndex.purs

@@ -13,11 +13,10 @@ import Data.Monoid.Disj (Disj)
 import Data.Monoid.Dual (Dual)
 import Data.Monoid.Multiplicative (Multiplicative)
 
-
--- | A `Functor` with an additional index.  
+-- | A `Functor` with an additional index.
 -- | Instances must satisfy a modified form of the `Functor` laws
 -- | ```purescript
--- | mapWithIndex (\_ a -> a) = id
+-- | mapWithIndex (\_ a -> a) = identity
 -- | mapWithIndex f . mapWithIndex g = mapWithIndex (\i -> f i <<< g i)
 -- | ```
 -- | and be compatible with the `Functor` instance

src/Data/Semigroup/Foldable.purs

@@ -39,7 +39,7 @@ class Foldable t <= Foldable1 t where
 
 -- | A default implementation of `fold1` using `foldMap1`.
 fold1Default :: forall t m. Foldable1 t => Semigroup m => t m -> m
-fold1Default = foldMap1 id
+fold1Default = foldMap1 identity
 
 -- | A default implementation of `foldMap1` using `fold1`.
 foldMap1Default :: forall t m a. Foldable1 t => Functor t => Semigroup m => (a -> m) -> t a -> m
@@ -76,7 +76,7 @@ for1_ = flip traverse1_
 -- | Perform all of the effects in some data structure in the order
 -- | given by the `Foldable1` instance, ignoring the final result.
 sequence1_ :: forall t f a. Foldable1 t => Apply f => t (f a) -> f Unit
-sequence1_ = traverse1_ id
+sequence1_ = traverse1_ identity
 
 maximum :: forall f a. Ord a => Foldable1 f => f a -> a
 maximum = ala Max foldMap1
@@ -96,7 +96,7 @@ instance semigroupJoinWith :: Semigroup a => Semigroup (JoinWith a) where
 -- | Fold a data structure using a `Semigroup` instance,
 -- | combining adjacent elements using the specified separator.
 intercalate :: forall f m. Foldable1 f => Semigroup m => m -> f m -> m
-intercalate = flip intercalateMap id
+intercalate = flip intercalateMap identity
 
 -- | Fold a data structure, accumulating values in some `Semigroup`,
 -- | combining adjacent elements using the specified separator.

src/Data/Semigroup/Traversable.purs

@@ -19,7 +19,7 @@ import Data.Traversable (class Traversable)
 -- | following sense:
 -- |
 -- | - `traverse1 f xs = sequence1 (f <$> xs)`
--- | - `sequence1 = traverse1 id`
+-- | - `sequence1 = traverse1 identity`
 -- |
 -- | `Traversable1` instances should also be compatible with the corresponding
 -- | `Foldable1` instances, in the following sense:
@@ -59,4 +59,4 @@ sequence1Default
   => Apply m
   => t (m a)
   -> m (t a)
-sequence1Default = traverse1 id
+sequence1Default = traverse1 identity

src/Data/Traversable.purs

@@ -36,7 +36,7 @@ import Data.Traversable.Accum.Internal (StateL(..), StateR(..), stateL, stateR)
 -- | following sense:
 -- |
 -- | - `traverse f xs = sequence (f <$> xs)`
--- | - `sequence = traverse id`
+-- | - `sequence = traverse identity`
 -- |
 -- | `Traversable` instances should also be compatible with the corresponding
 -- | `Foldable` instances, in the following sense:
@@ -68,7 +68,7 @@ sequenceDefault
   => Applicative m
   => t (m a)
   -> m (t a)
-sequenceDefault = traverse id
+sequenceDefault = traverse identity
 
 instance traversableArray :: Traversable Array where
   traverse = traverseArrayImpl apply map pure