Refine imports

Author: garyb

src/Control/Monad/Eff/Ref.purs

@@ -7,7 +7,7 @@
 
 module Control.Monad.Eff.Ref where
 
-import Control.Monad.Eff
+import Control.Monad.Eff (Eff())
 
 -- | The effect associated with the use of global mutable variables.
 foreign import data REF :: !
@@ -17,26 +17,29 @@ foreign import data REF :: !
 foreign import data Ref :: * -> *
 
 -- | Create a new mutable reference containing the specified value.
-foreign import newRef """
+foreign import newRef
+  """
   function newRef(val) {
     return function () {
       return { value: val };
     };
   }
-""" :: forall s r. s -> Eff (ref :: REF | r) (Ref s)
+  """ :: forall s r. s -> Eff (ref :: REF | r) (Ref s)
 
 -- | Read the current value of a mutable reference
-foreign import readRef """
+foreign import readRef
+  """
   function readRef(ref) {
     return function() {
       return ref.value;
     };
   }
-""" :: forall s r. Ref s -> Eff (ref :: REF | r) s
+  """ :: forall s r. Ref s -> Eff (ref :: REF | r) s
 
 -- | Update the value of a mutable reference by applying a function
 -- | to the current value.
-foreign import modifyRef' """
+foreign import modifyRef'
+  """
   function modifyRef$prime(ref) {
     return function(f) {
       return function() {
@@ -46,15 +49,16 @@ foreign import modifyRef' """
       };
     };
   }
-""" :: forall s b r. Ref s -> (s -> { state :: s, value :: b }) -> Eff (ref :: REF | r) b
+  """ :: forall s b r. Ref s -> (s -> { state :: s, value :: b }) -> Eff (ref :: REF | r) b
 
 -- | Update the value of a mutable reference by applying a function
 -- | to the current value.
 modifyRef :: forall s r. Ref s -> (s -> s) -> Eff (ref :: REF | r) Unit
 modifyRef ref f = modifyRef' ref (\s -> { state: f s, value: unit })
 
 -- | Update the value of a mutable reference to the specified value.
-foreign import writeRef """
+foreign import writeRef
+  """
   function writeRef(ref) {
     return function(val) {
       return function() {
@@ -63,4 +67,4 @@ foreign import writeRef """
       };
     };
   }
-""" :: forall s r. Ref s -> s -> Eff (ref :: REF | r) Unit
+  """ :: forall s r. Ref s -> s -> Eff (ref :: REF | r) Unit

src/Control/Monad/Eff/Ref/Unsafe.purs

@@ -2,7 +2,7 @@
 
 module Control.Monad.Eff.Ref.Unsafe where
 
-import Control.Monad.Eff
+import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Ref
 
 -- | This handler function unsafely removes the `Ref` effect from an
@@ -11,7 +11,9 @@ import Control.Monad.Eff.Ref
 -- | This function might be used when it is impossible to prove to the
 -- | typechecker that a particular mutable reference does not escape
 -- | its scope.
-foreign import unsafeRunRef 
-  "function unsafeRunRef(f) {\
-  \  return f;\
-  \}" :: forall eff a. Eff (ref :: REF | eff) a -> Eff eff a
+foreign import unsafeRunRef
+  """
+  function unsafeRunRef(f) {
+    return f;
+  }
+  """ :: forall eff a. Eff (ref :: REF | eff) a -> Eff eff a