initial updates for 0.12

Author: kritzcreek

bower.json

@@ -21,12 +21,12 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-arrays": "^4.0.0",
-    "purescript-functions": "^3.0.0",
-    "purescript-lists": "^4.0.0",
-    "purescript-st": "^3.0.0",
-    "purescript-gen": "^1.1.0",
-    "purescript-foldable-traversable": "^3.6.1"
+    "purescript-arrays": "#compiler/0.12",
+    "purescript-functions": "#compiler/0.12",
+    "purescript-lists": "#compiler/0.12",
+    "purescript-st": "#compiler/0.12",
+    "purescript-gen": "#compiler/0.12",
+    "purescript-foldable-traversable": "#compiler/0.12"
   },
   "devDependencies": {
     "purescript-quickcheck": "^4.0.0",

src/Data/Map.purs

@@ -49,7 +49,6 @@ import Data.FunctorWithIndex (class FunctorWithIndex, mapWithIndex)
 import Data.List (List(..), (:), length, nub)
 import Data.List.Lazy as LL
 import Data.Maybe (Maybe(..), maybe, isJust, fromMaybe)
-import Data.Monoid (class Monoid, mempty)
 import Data.Ord (class Ord1)
 import Data.Traversable (traverse, class Traversable)
 import Data.TraversableWithIndex (class TraversableWithIndex, traverseWithIndex)
@@ -109,7 +108,7 @@ instance foldableWithIndexMap :: FoldableWithIndex k (Map k) where
   foldMapWithIndex f m = foldMap (uncurry f) $ asList $ toUnfoldable m
 
 asList :: forall k v. List (Tuple k v) -> List (Tuple k v)
-asList = id
+asList = identity
 
 instance traversableMap :: Traversable (Map k) where
   traverse f Leaf = pure Leaf
@@ -126,7 +125,7 @@ instance traversableMap :: Traversable (Map k) where
           <*> pure k2
           <*> f v2
           <*> traverse f right
-  sequence = traverse id
+  sequence = traverse identity
 
 instance traversableWithIndexMap :: TraversableWithIndex k (Map k) where
   traverseWithIndex f Leaf = pure Leaf

src/Data/StrMap.purs

@@ -44,17 +44,14 @@ module Data.StrMap
 
 import Prelude
 
-import Control.Monad.Eff (Eff, runPure, foreachE)
-import Control.Monad.ST as ST
-
+import Control.Monad.ST (ST)
 import Data.Array as A
 import Data.Eq (class Eq1)
 import Data.Foldable (class Foldable, foldl, foldr, for_)
 import Data.FoldableWithIndex (class FoldableWithIndex)
 import Data.Function.Uncurried (Fn2, runFn2, Fn4, runFn4)
 import Data.FunctorWithIndex (class FunctorWithIndex)
 import Data.Maybe (Maybe(..), maybe, fromMaybe)
-import Data.Monoid (class Monoid, mempty)
 import Data.StrMap.ST as SM
 import Data.Traversable (class Traversable, traverse)
 import Data.TraversableWithIndex (class TraversableWithIndex, traverseWithIndex)
@@ -64,26 +61,26 @@ import Data.Unfoldable (class Unfoldable)
 -- | `StrMap a` represents a map from `String`s to values of type `a`.
 foreign import data StrMap :: Type -> Type
 
-foreign import _copyEff :: forall a b h r. a -> Eff (st :: ST.ST h | r) b
+foreign import _copyEff :: forall a b h. a -> ST h b
 
 -- | Convert an immutable map into a mutable map
-thawST :: forall a h r. StrMap a -> Eff (st :: ST.ST h | r) (SM.STStrMap h a)
+thawST :: forall a h. StrMap a -> ST h (SM.STStrMap h a)
 thawST = _copyEff
 
 -- | Convert a mutable map into an immutable map
-freezeST :: forall a h r. SM.STStrMap h a -> Eff (st :: ST.ST h | r) (StrMap a)
+freezeST :: forall a h. SM.STStrMap h a -> ST h (StrMap a)
 freezeST = _copyEff
 
 -- | Freeze a mutable map, creating an immutable map. Use this function as you would use
 -- | `Prelude.runST` to freeze a mutable reference.
 -- |
 -- | The rank-2 type prevents the map from escaping the scope of `runST`.
-foreign import runST :: forall a r. (forall h. Eff (st :: ST.ST h | r) (SM.STStrMap h a)) -> Eff r (StrMap a)
+foreign import runST :: forall a. (forall h. ST h (SM.STStrMap h a)) -> StrMap a
 
-pureST :: forall a. (forall h e. Eff (st :: ST.ST h | e) (SM.STStrMap h a)) -> StrMap a
-pureST f = runPure (runST f)
+pureST :: forall a. (forall h e. ST h (SM.STStrMap h a)) -> StrMap a
+pureST = runST
 
-mutate :: forall a b. (forall h e. SM.STStrMap h a -> Eff (st :: ST.ST h | e) b) -> StrMap a -> StrMap a
+mutate :: forall a b. (forall h. SM.STStrMap h a -> ST h b) -> StrMap a -> StrMap a
 mutate f m = pureST do
   s <- thawST m
   _ <- f s
@@ -125,7 +122,7 @@ instance foldableWithIndexStrMap :: FoldableWithIndex String StrMap where
 
 instance traversableStrMap :: Traversable StrMap where
   traverse = traverseWithIndex <<< const
-  sequence = traverse id
+  sequence = traverse identity
 
 instance traversableWithIndexStrMap :: TraversableWithIndex String StrMap where
   traverseWithIndex f ms =
@@ -222,10 +219,10 @@ update f k m = alter (maybe Nothing f) k m
 fromFoldable :: forall f a. Foldable f => f (Tuple String a) -> StrMap a
 fromFoldable l = pureST do
   s <- SM.new
-  foreachE (A.fromFoldable l) \(Tuple k v) -> void (SM.poke s k v)
+  for_ (A.fromFoldable l) \(Tuple k v) -> void (SM.poke s k v)
   pure s
 
-foreign import _lookupST :: forall a h r z. Fn4 z (a -> z) String (SM.STStrMap h a) (Eff (st :: ST.ST h | r) z)
+foreign import _lookupST :: forall a h z. Fn4 z (a -> z) String (SM.STStrMap h a) (ST h z)
 
 -- | Create a map from a foldable collection of key/value pairs, using the
 -- | specified function to combine values for duplicate keys.
@@ -283,7 +280,7 @@ instance monoidStrMap :: (Semigroup a) => Monoid (StrMap a) where
 filterWithKey :: forall a. (String -> a -> Boolean) -> StrMap a -> StrMap a
 filterWithKey predicate m = pureST go
   where
-  go :: forall h e. Eff (st :: ST.ST h | e) (SM.STStrMap h a)
+  go :: forall h. ST h (SM.STStrMap h a)
   go = do
     m' <- SM.new
     foldM step m' m

src/Data/StrMap/ST.purs

@@ -10,28 +10,27 @@ module Data.StrMap.ST
   , delete
   ) where
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.ST (ST)
+import Control.Monad.ST (ST, kind Region)
 import Data.Maybe (Maybe(..))
 
 -- | A reference to a mutable map
 -- |
 -- | The first type parameter represents the memory region which the map belongs to. The second type parameter defines the type of elements of the mutable array.
 -- |
 -- | The runtime representation of a value of type `STStrMap h a` is the same as that of `StrMap a`, except that mutation is allowed.
-foreign import data STStrMap :: Type -> Type -> Type
+foreign import data STStrMap :: Region -> Type -> Type
 
 -- | Create a new, empty mutable map
-foreign import new :: forall a h r. Eff (st :: ST h | r) (STStrMap h a)
+foreign import new :: forall a h. ST h (STStrMap h a)
 
 -- | Get the value for a key in a mutable map
-peek :: forall a h r. STStrMap h a -> String -> Eff (st :: ST h | r) (Maybe a)
+peek :: forall a h. STStrMap h a -> String -> ST h (Maybe a)
 peek = peekImpl Just Nothing
 
-foreign import peekImpl :: forall a b h r. (a -> b) -> b -> STStrMap h a -> String -> Eff (st :: ST h | r) b
+foreign import peekImpl :: forall a b h. (a -> b) -> b -> STStrMap h a -> String -> ST h b
 
 -- | Update the value for a key in a mutable map
-foreign import poke :: forall a h r. STStrMap h a -> String -> a -> Eff (st :: ST h | r) (STStrMap h a)
+foreign import poke :: forall a h. STStrMap h a -> String -> a -> ST h (STStrMap h a)
 
 -- | Remove a key and the corresponding value from a mutable map
-foreign import delete :: forall a h r. STStrMap h a -> String -> Eff (st :: ST h | r) (STStrMap h a)
+foreign import delete :: forall a h. STStrMap h a -> String -> ST h (STStrMap h a)

src/Data/StrMap/ST/Unsafe.purs

@@ -1,11 +1,9 @@
 module Data.StrMap.ST.Unsafe where
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.ST (ST)
 import Data.StrMap (StrMap)
 import Data.StrMap.ST (STStrMap)
 
 -- | Unsafely get the map out of ST without copying it
 -- |
 -- | If you later change the ST version of the map the pure value will also change.
-foreign import unsafeFreeze :: forall a h r. STStrMap h a -> Eff (st :: ST h | r) (StrMap a)
+foreign import unsafeFreeze :: forall a h. STStrMap h a -> StrMap a