Updates for 0.12

Author: garyb

bower.json

@@ -17,6 +17,6 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-effect": "^0.1.0"
+    "purescript-effect": "#compiler/0.12"
   }
 }

src/Control/Monad/Effect/Ref.js src/Effect/Ref.jssrc/Control/Monad/Effect/Ref.js renamed to src/Effect/Ref.js

@@ -1,19 +1,19 @@
 "use strict";
 
-exports.newRef = function (val) {
+exports.new = function (val) {
   return function () {
     return { value: val };
   };
 };
 
-exports.readRef = function (ref) {
+exports.read = function (ref) {
   return function () {
     return ref.value;
   };
 };
 
-exports["modifyRef'"] = function (ref) {
-  return function (f) {
+exports["modify'"] = function (f) {
+  return function (ref) {
     return function () {
       var t = f(ref.value);
       ref.value = t.state;
@@ -22,8 +22,8 @@ exports["modifyRef'"] = function (ref) {
   };
 };
 
-exports.writeRef = function (ref) {
-  return function (val) {
+exports.write = function (val) {
+  return function (ref) {
     return function () {
       ref.value = val;
       return {};

src/Control/Monad/Effect/Ref.purs src/Effect/Ref.purssrc/Control/Monad/Effect/Ref.purs renamed to src/Effect/Ref.purs

@@ -1,32 +1,33 @@
 -- | This module defines an effect and actions for working with
 -- | global mutable variables.
 -- |
--- | _Note_: The `Control.Monad.ST` provides a _safe_ alternative
+-- | _Note_: `Control.Monad.ST` provides a _safe_ alternative
 -- | to global mutable variables when mutation is restricted to a
 -- | local scope.
-module Control.Monad.Effect.Ref where
+module Effect.Ref where
 
-import Control.Monad.Effect (Effect)
-import Prelude (Unit, unit)
+import Prelude
+
+import Effect (Effect)
 
 -- | A value of type `Ref a` represents a mutable reference
 -- | which holds a value of type `a`.
 foreign import data Ref :: Type -> Type
 
 -- | Create a new mutable reference containing the specified value.
-foreign import newRef :: forall s. s -> Effect (Ref s)
+foreign import new :: forall s. s -> Effect (Ref s)
 
 -- | Read the current value of a mutable reference
-foreign import readRef :: forall s. Ref s -> Effect s
+foreign import read :: forall s. Ref s -> Effect s
 
 -- | Update the value of a mutable reference by applying a function
 -- | to the current value.
-foreign import modifyRef' :: forall s b. Ref s -> (s -> { state :: s, value :: b }) -> Effect b
+foreign import modify' :: forall s b. (s -> { state :: s, value :: b }) -> Ref s -> Effect b
 
 -- | Update the value of a mutable reference by applying a function
 -- | to the current value.
-modifyRef :: forall s. Ref s -> (s -> s) -> Effect Unit
-modifyRef ref f = modifyRef' ref (\s -> { state: f s, value: unit })
+modify :: forall s. (s -> s) -> Ref s -> Effect Unit
+modify f = modify' (\s -> { state: f s, value: unit })
 
 -- | Update the value of a mutable reference to the specified value.
-foreign import writeRef :: forall s. Ref s -> s -> Effect Unit
+foreign import write :: forall s. s -> Ref s -> Effect Unit