Merge pull request #18 from purescript/rec-instance-internal-module

Adds a MonadRec instance for ST, introduces an Internal module

Author: kritzcreek

bower.json

@@ -17,7 +17,8 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-prelude": "#compiler/0.12"
+    "purescript-prelude": "#compiler/0.12",
+    "purescript-tailrec": "#compiler/0.12"
   },
   "devDependencies": {
     "purescript-console": "#compiler/0.12"

src/Control/Monad/ST.js

@@ -1,58 +1,3 @@
-module Control.Monad.ST
-  ( kind Region
-  , ST
-  , run
-  , while
-  ) where
+module Control.Monad.ST (module Internal) 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.
-foreign import kind Region
-
--- | 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 `run` function can be used to run a computation in the `ST` monad.
-foreign import data ST :: Region -> Type -> Type
-
-foreign import map_ :: forall r a b. (a -> b) -> ST r a -> ST r b
-
-foreign import pure_ :: forall r a. a -> ST r a
-
-foreign import bind_ :: forall r a b. ST r a -> (a -> ST r b) -> ST r b
-
-instance functorST :: Functor (ST r) where
-  map = map_
-
-instance applyST :: Apply (ST r) where
-  apply = ap
-
-instance applicativeST :: Applicative (ST r) where
-  pure = pure_
-
-instance bindST :: Bind (ST r) where
-  bind = bind_
-
-instance monadST :: Monad (ST r)
-
--- | Run an `ST` computation.
--- |
--- | 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. 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`.
--- |
--- | `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
+import Control.Monad.ST.Internal (ST, kind Region, run, while) as Internal

src/Control/Monad/ST.purs

@@ -1,5 +1,41 @@
 "use strict";
 
+exports.map_ = function (f) {
+  return function (a) {
+    return function () {
+      return f(a());
+    };
+  };
+};
+
+exports.pure_ = function (a) {
+  return function () {
+    return a;
+  };
+};
+
+exports.bind_ = function (a) {
+  return function (f) {
+    return function () {
+      return f(a())();
+    };
+  };
+};
+
+exports.run = function (f) {
+  return f();
+};
+
+exports["while"] = function (f) {
+  return function (a) {
+    return function () {
+      while (f()) {
+        a();
+      }
+    };
+  };
+};
+
 exports.new = function (val) {
   return function () {
     return { value: val };

src/Control/Monad/ST/Ref.js renamed to src/Control/Monad/ST/Internal.js

@@ -0,0 +1,97 @@
+module Control.Monad.ST.Internal where
+
+import Prelude
+
+import Control.Monad.Rec.Class (class MonadRec, Step(..))
+import Partial.Unsafe (unsafePartial)
+
+-- | `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.
+-- |
+-- | 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 `run` function can be used to run a computation in the `ST` monad.
+foreign import data ST :: Region -> Type -> Type
+
+foreign import map_ :: forall r a b. (a -> b) -> ST r a -> ST r b
+
+foreign import pure_ :: forall r a. a -> ST r a
+
+foreign import bind_ :: forall r a b. ST r a -> (a -> ST r b) -> ST r b
+
+instance functorST :: Functor (ST r) where
+  map = map_
+
+instance applyST :: Apply (ST r) where
+  apply = ap
+
+instance applicativeST :: Applicative (ST r) where
+  pure = pure_
+
+instance bindST :: Bind (ST r) where
+  bind = bind_
+
+instance monadST :: Monad (ST r)
+
+instance monadRecST :: MonadRec (ST r) where
+  tailRecM f a = do
+    r <- new =<< f a
+    while (isDone <$> read r) do
+      read r >>= case _ of
+        Loop a' -> do
+          e <- f a'
+          void (write e r)
+        Done b -> pure unit
+    fromDone <$> read r
+    where
+      fromDone :: forall a b. Step a b -> b
+      fromDone = unsafePartial \(Done b) -> b
+
+      isDone = case _ of
+        Done _ -> true
+        _ -> false
+
+-- | Run an `ST` computation.
+-- |
+-- | 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. 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`.
+-- |
+-- | `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
+
+-- | 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

src/Control/Monad/ST/Internal.purs

@@ -1,28 +1,3 @@
-module Control.Monad.ST.Ref where
+module Control.Monad.ST.Ref (module Internal) 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
+import Control.Monad.ST.Internal (STRef, new, read, modify, modify', write) as Internal