Dependency updates, drop ST naming from functions, put STRef argument last

Author: garyb

bower.json

@@ -16,10 +16,10 @@
     "bower.json",
     "package.json"
   ],
-  "devDependencies": {
-    "purescript-console": "^3.0.0"
-  },
   "dependencies": {
-    "purescript-prelude": "^3.1.1"
+    "purescript-prelude": "#compiler/0.12"
+  },
+  "devDependencies": {
+    "purescript-console": "#compiler/0.12"
   }
 }

src/Control/Monad/ST.js

@@ -1,55 +1,37 @@
 "use strict";
 
-exports.mapST = function (f) {
+exports.map_ = function (f) {
   return function (a) {
     return function () {
       return f(a());
     };
   };
 };
 
-exports.pureST_ = function (a) {
+exports.pure_ = function (a) {
   return function () {
     return a;
   };
 };
 
-exports.bindST_ = function (a) {
+exports.bind_ = function (a) {
   return function (f) {
     return function () {
       return f(a())();
     };
   };
 };
 
-exports.newSTRef = function (val) {
-  return function () {
-    return { value: val };
-  };
-};
-
-exports.readSTRef = function (ref) {
-  return function () {
-    return ref.value;
-  };
-};
-
-exports.modifySTRef = function (ref) {
-  return function (f) {
-    return function () {
-      return ref.value = f(ref.value); // eslint-disable-line no-return-assign
-    };
-  };
+exports.run = function (f) {
+  return f();
 };
 
-exports.writeSTRef = function (ref) {
+exports["while"] = function (f) {
   return function (a) {
     return function () {
-      return ref.value = a; // eslint-disable-line no-return-assign
+      while (f()) {
+        a();
+      }
     };
   };
 };
-
-exports.pureST = function (f) {
-  return f();
-};

src/Control/Monad/ST.purs

@@ -1,84 +1,58 @@
 module Control.Monad.ST
   ( kind Region
   , ST
-  , STRef
-  , newSTRef
-  , readSTRef
-  , modifySTRef
-  , writeSTRef
-  , pureST
+  , run
+  , while
   ) where
 
 import Prelude
 
--- | `ST` is concerned with _restricted_ mutation. Mutation
--- | is restricted to a _region_ of mutable references.
--- | This kind is inhabited by phantom types which represent
--- | regions in the type system.
+-- | `ST` is concerned with _restricted_ mutation. Mutation is restricted to a
+-- | _region_ of mutable references. This kind is inhabited by phantom types
+-- | which represent regions in the type system.
 foreign import kind Region
 
--- | The `ST` type constructor allows _local mutation_, i.e.
--- | mutation which does not "escape" into the surrounding
--- | computation.
+-- | The `ST` type constructor allows _local mutation_, i.e. mutation which
+-- | does not "escape" into the surrounding computation.
 -- |
 -- | An `ST` computation is parameterized by a phantom type which is used to
 -- | restrict the set of reference cells it is allowed to access.
 -- |
--- | The `runST` function can be used to run a computation in the
--- | `ST` monad.
+-- | The `run` function can be used to run a computation in the `ST` monad.
 foreign import data ST :: Region -> Type -> Type
 
-foreign import mapST
-  :: forall r a b
-   . (a -> b)
-  -> ST r a
-  -> ST r b
+foreign import map_ :: forall r a b. (a -> b) -> ST r a -> ST r b
 
-foreign import pureST_ :: forall r a. a -> ST r a
+foreign import pure_ :: forall r a. a -> ST r a
 
-foreign import bindST_
-  :: forall r a b
-   . ST r a
-  -> (a -> ST r b)
-  -> ST r b
+foreign import bind_ :: forall r a b. ST r a -> (a -> ST r b) -> ST r b
 
 instance functorST :: Functor (ST r) where
-  map = mapST
+  map = map_
 
 instance applyST :: Apply (ST r) where
   apply = ap
 
 instance applicativeST :: Applicative (ST r) where
-  pure = pureST_
+  pure = pure_
 
 instance bindST :: Bind (ST r) where
-  bind = bindST_
+  bind = bind_
 
 instance monadST :: Monad (ST r)
 
--- | The type `STRef r a` represents a mutable reference holding a value of
--- | type `a`, which can be used with the `ST r` effect.
-foreign import data STRef :: Region -> Type -> Type
-
--- | Create a new mutable reference.
-foreign import newSTRef :: forall a r. a -> ST r (STRef r a)
-
--- | Read the current value of a mutable reference.
-foreign import readSTRef :: forall a r. STRef r a -> ST r a
-
--- | Modify the value of a mutable reference by applying a function to the
--- | current value.
-foreign import modifySTRef :: forall a r. STRef r a -> (a -> a) -> ST r a
-
--- | Set the value of a mutable reference.
-foreign import writeSTRef :: forall a r. STRef r a -> a -> ST r a
-
 -- | Run an `ST` computation.
 -- |
--- | Note: the type of `runST` uses a rank-2 type to constrain the phantom
+-- | Note: the type of `run` uses a rank-2 type to constrain the phantom
 -- | type `h`, such that the computation must not leak any mutable references
--- | to the surrounding computation.
+-- | to the surrounding computation. It may cause problems to apply this
+-- | function using the `$` operator. The recommended approach is to use
+-- | parentheses instead.
+foreign import run :: forall a. (forall r. ST r a) -> a
+
+-- | Loop while a condition is `true`.
 -- |
--- | It may cause problems to apply this function using the `$` operator. The
--- | recommended approach is to use parentheses instead.
-foreign import pureST :: forall a. (forall r. ST r a) -> a
+-- | `while b m` is ST computation which runs the ST computation `b`. If its
+-- | result is `true`, it runs the ST computation `m` and loops. If not, the
+-- | computation ends.
+foreign import while :: forall r a. ST r Boolean -> ST r a -> ST r Unit

src/Control/Monad/ST/Ref.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.new = function (val) {
+  return function () {
+    return { value: val };
+  };
+};
+
+exports.read = function (ref) {
+  return function () {
+    return ref.value;
+  };
+};
+
+exports["modify'"] = function (f) {
+  return function (ref) {
+    return function () {
+      var t = f(ref.value);
+      ref.value = t.state;
+      return t.value;
+    };
+  };
+};
+
+exports.write = function (a) {
+  return function (ref) {
+    return function () {
+      return ref.value = a; // eslint-disable-line no-return-assign
+    };
+  };
+};

src/Control/Monad/ST/Ref.purs

@@ -0,0 +1,28 @@
+module Control.Monad.ST.Ref where
+
+import Prelude
+
+import Control.Monad.ST (ST, kind Region)
+
+-- | The type `STRef r a` represents a mutable reference holding a value of
+-- | type `a`, which can be used with the `ST r` effect.
+foreign import data STRef :: Region -> Type -> Type
+
+-- | Create a new mutable reference.
+foreign import new :: forall a r. a -> ST r (STRef r a)
+
+-- | Read the current value of a mutable reference.
+foreign import read :: forall a r. STRef r a -> ST r a
+
+-- | Update the value of a mutable reference by applying a function
+-- | to the current value, computing a new state value for the reference and
+-- | a return value.
+foreign import modify' :: forall r a b. (a -> { state :: a, value :: b }) -> STRef r a -> ST r b
+
+-- | Modify the value of a mutable reference by applying a function to the
+-- | current value.
+modify :: forall r a. (a -> a) -> STRef r a -> ST r Unit
+modify f = modify' (\s -> { state: f s, value: unit })
+
+-- | Set the value of a mutable reference.
+foreign import write :: forall a r. a -> STRef r a -> ST r a

test/Main.purs

@@ -2,19 +2,20 @@ module Test.Main where
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, logShow)
-import Control.Monad.ST (modifySTRef, newSTRef, readSTRef, pureST)
+import Effect (Effect)
+import Effect.Console (logShow)
+import Control.Monad.ST as ST
+import Control.Monad.ST.Ref as STRef
 
 sumOfSquares :: Int
-sumOfSquares = pureST do
-  total <- newSTRef 0
-  let loop 0 = readSTRef total
+sumOfSquares = ST.run do
+  total <- STRef.new 0
+  let loop 0 = STRef.read total
       loop n = do
-        _ <- modifySTRef total (_ + (n * n))
+        _ <- STRef.modify (_ + (n * n)) total
         loop (n - 1)
   loop 100
 
-main :: Eff (console :: CONSOLE) Unit
+main :: Effect Unit
 main = do
   logShow sumOfSquares