Initial commit

Author: paf31

.gitignore

@@ -0,0 +1,4 @@
+output
+bower_components
+.psci
+.psci_modules

README.md

@@ -0,0 +1,86 @@
+# Important notice
+
+This module should not yet be depended on, it is for the upcoming 0.7 compiler release.
+
+# Module Documentation
+
+## Module Control.Monad.ST
+
+#### `ST`
+
+``` purescript
+data ST :: * -> !
+```
+
+The `ST` effect represents _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 handle the `ST` effect.
+
+#### `STRef`
+
+``` purescript
+data STRef :: * -> * -> *
+```
+
+The type `STRef s a` represents a mutable reference holding a value of type `a`, which can be used with the `ST s` effect.
+
+#### `newSTRef`
+
+``` purescript
+newSTRef :: forall a h r. a -> Eff (st :: ST h | r) (STRef h a)
+```
+
+Create a new mutable reference.
+
+#### `readSTRef`
+
+``` purescript
+readSTRef :: forall a h r. STRef h a -> Eff (st :: ST h | r) a
+```
+
+Read the current value of a mutable reference.
+
+#### `modifySTRef`
+
+``` purescript
+modifySTRef :: forall a h r. STRef h a -> (a -> a) -> Eff (st :: ST h | r) a
+```
+
+Modify the value of a mutable reference by applying a function to the current value.
+
+#### `writeSTRef`
+
+``` purescript
+writeSTRef :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a
+```
+
+Set the value of a mutable reference.
+
+#### `runST`
+
+``` purescript
+runST :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a
+```
+
+Run an `ST` computation.
+
+Note: the type of `runST` uses a rank-2 type to constrain the phantom type `s`, 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.
+
+#### `pureST`
+
+``` purescript
+pureST :: forall a. (forall h r. Eff (st :: ST h | r) a) -> a
+```
+
+A convenience function which combines `runST` with `runPure`, which can be used when the only required effect is `ST`.
+
+Note: since this function has a rank-2 type, it may cause problems to apply this function using the `$` operator. The recommended approach
+is to use parentheses instead.
+
+
+

bower.json

@@ -0,0 +1,16 @@
+{
+  "name": "purescript-st",
+  "version": "0.1.0",
+  "moduleType": [
+    "node"
+  ],
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-eff": "~0.1.0"
+  }
+}

src/Control/Monad/ST.purs

@@ -0,0 +1,77 @@
+module Control.Monad.ST where
+
+import Control.Monad.Eff
+
+-- | The `ST` effect represents _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 handle the `ST` effect.
+foreign import data ST :: * -> !
+
+-- | The type `STRef s a` represents a mutable reference holding a value of type `a`, which can be used with the `ST s` effect.
+foreign import data STRef :: * -> * -> *
+
+-- | Create a new mutable reference.
+foreign import newSTRef
+  """
+  function newSTRef(val) {
+    return function() {
+      return { value: val };
+    };
+  }
+  """ :: forall a h r. a -> Eff (st :: ST h | r) (STRef h a)
+
+-- | Read the current value of a mutable reference.
+foreign import readSTRef
+  """
+  function readSTRef(ref) {
+    return function() {
+      return ref.value;
+    };
+  }
+  """ :: forall a h r. STRef h a -> Eff (st :: ST h | r) a
+
+-- | Modify the value of a mutable reference by applying a function to the current value.
+foreign import modifySTRef
+  """
+  function modifySTRef(ref) {
+    return function(f) {
+      return function() {
+        return ref.value = f(ref.value);
+      };
+    };
+  }
+  """ :: forall a h r. STRef h a -> (a -> a) -> Eff (st :: ST h | r) a
+
+-- | Set the value of a mutable reference.
+foreign import writeSTRef
+  """
+  function writeSTRef(ref) {
+    return function(a) {
+      return function() {
+        return ref.value = a;
+      };
+    };
+  }
+  """ :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a
+
+-- | Run an `ST` computation.
+-- |
+-- | Note: the type of `runST` uses a rank-2 type to constrain the phantom type `s`, 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 runST
+  """
+  function runST(f) {
+    return f;
+  }
+  """ :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a
+
+-- | A convenience function which combines `runST` with `runPure`, which can be used when the only required effect is `ST`.
+-- |
+-- | Note: since this function has a rank-2 type, it may cause problems to apply this function using the `$` operator. The recommended approach
+-- | is to use parentheses instead.
+pureST :: forall a. (forall h r. Eff (st :: ST h | r) a) -> a
+pureST st = runPure (runST st)