Rearrange things to avoid dodgy FFI dependency

Author: garyb

bower.json

@@ -20,8 +20,9 @@
     "purescript-console": "^1.0.0",
     "purescript-exceptions": "^1.0.0",
     "purescript-functions": "^1.0.0",
+    "purescript-parallel": "^1.0.0",
     "purescript-transformers": "^1.0.0",
-    "purescript-parallel": "^1.0.0"
+    "purescript-unsafe-coerce": "^1.0.0"
   },
   "devDependencies": {
     "purescript-partial": "^1.1.2"

src/Control/Monad/Aff.js

@@ -320,11 +320,3 @@ exports._tailRecM = function (isLeft, f, a) {
     }(a);
   };
 };
-
-
-var avar = require("../Control.Monad.Aff.AVar/foreign.js");
-
-exports._makeVar = avar._makeVar;
-exports._takeVar = avar._takeVar;
-exports._putVar = avar._putVar;
-exports._killVar = avar._killVar;

src/Control/Monad/Aff.purs

@@ -24,6 +24,7 @@ import Prelude
 
 import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
+import Control.Monad.Aff.Internal (AVBox, AVar, _killVar, _putVar, _takeVar, _makeVar)
 import Control.Monad.Cont.Class (class MonadCont)
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Class (class MonadEff)
@@ -39,6 +40,8 @@ import Data.Foldable (class Foldable, foldl)
 import Data.Function.Uncurried (Fn2, Fn3, runFn2, runFn3)
 import Data.Monoid (class Monoid, mempty)
 
+import Unsafe.Coerce (unsafeCoerce)
+
 -- | An asynchronous computation with effects `e`. The computation either
 -- | errors or produces a value of type `a`.
 -- |
@@ -57,7 +60,7 @@ type PureAff a = forall e. Aff e a
 newtype Canceler e = Canceler (Error -> Aff e Boolean)
 
 -- | Unwraps the canceler function from the newtype that wraps it.
-cancel :: forall e. Canceler e -> Error ->  Aff e Boolean
+cancel :: forall e. Canceler e -> Error -> Aff e Boolean
 cancel (Canceler f) = f
 
 -- | This function allows you to attach a custom canceler to an asynchronous
@@ -207,8 +210,8 @@ instance monoidCanceler :: Monoid (Canceler e) where
 
 instance monadParAff :: MonadPar (Aff e) where
   par f ma mb = do
-    va <- _makeVar nonCanceler
-    vb <- _makeVar nonCanceler
+    va <- makeVar
+    vb <- makeVar
     c1 <- forkAff (putOrKill va =<< attempt ma)
     c2 <- forkAff (putOrKill vb =<< attempt mb)
     f <$> (takeVar va) <*> (takeVar vb)
@@ -219,8 +222,8 @@ instance monadParAff :: MonadPar (Aff e) where
 instance monadRaceAff :: MonadRace (Aff e) where
   stall = throwError $ error "Stalled"
   race a1 a2 = do
-    va <- _makeVar nonCanceler -- the `a` value
-    ve <- _makeVar nonCanceler -- the error count (starts at 0)
+    va <- makeVar -- the `a` value
+    ve <- makeVar -- the error count (starts at 0)
     putVar ve 0
     c1 <- forkAff $ either (maybeKill va ve) (putVar va) =<< attempt a1
     c2 <- forkAff $ either (maybeKill va ve) (putVar va) =<< attempt a2
@@ -232,28 +235,20 @@ instance monadRaceAff :: MonadRace (Aff e) where
       if e == 1 then killVar va err else pure unit
       putVar ve (e + 1)
 
---------------------------------
-
-foreign import data AVar :: * -> *
+makeVar :: forall e a. Aff e (AVar a)
+makeVar = fromAVBox $ _makeVar nonCanceler
 
 takeVar :: forall e a. AVar a -> Aff e a
-takeVar q = runFn2 _takeVar nonCanceler q
+takeVar q = fromAVBox $ runFn2 _takeVar nonCanceler q
 
 putVar :: forall e a. AVar a -> a -> Aff e Unit
-putVar q a = runFn3 _putVar nonCanceler q a
+putVar q a = fromAVBox $ runFn3 _putVar nonCanceler q a
 
 killVar :: forall e a. AVar a -> Error -> Aff e Unit
-killVar q e = runFn3 _killVar nonCanceler q e
-
-foreign import _makeVar :: forall e a. Canceler e -> Aff e (AVar a)
-
-foreign import _takeVar :: forall e a. Fn2 (Canceler e) (AVar a) (Aff e a)
-
-foreign import _putVar :: forall e a. Fn3 (Canceler e) (AVar a) a (Aff e Unit)
-
-foreign import _killVar :: forall e a. Fn3 (Canceler e) (AVar a) Error (Aff e Unit)
+killVar q e = fromAVBox $ runFn3 _killVar nonCanceler q e
 
---------------------------------
+fromAVBox :: forall a e. AVBox a -> Aff e a
+fromAVBox = unsafeCoerce
 
 foreign import _cancelWith :: forall e a. Fn3 (Canceler e) (Aff e a) (Canceler e) (Aff e a)
 

src/Control/Monad/Aff/AVar.purs

@@ -1,32 +1,34 @@
 -- | A low-level primitive for building asynchronous code.
 module Control.Monad.Aff.AVar
-  ( AffAVar()
-  , AVar()
-  , AVAR()
-  , killVar
+  ( AffAVar
+  , AVAR
   , makeVar
   , makeVar'
-  , modifyVar
-  , putVar
   , takeVar
+  , putVar
+  , modifyVar
+  , killVar
+  , module Exports
   ) where
 
 import Prelude
 
-import Control.Monad.Aff (Aff(), Canceler(), nonCanceler)
+import Control.Monad.Aff (Aff, nonCanceler)
+import Control.Monad.Aff.Internal (AVar) as Exports
+import Control.Monad.Aff.Internal (AVBox, AVar, _killVar, _putVar, _takeVar, _makeVar)
 import Control.Monad.Eff.Exception (Error())
 
-import Data.Function.Uncurried (Fn2(), Fn3(), runFn2, runFn3)
+import Data.Function.Uncurried (runFn3, runFn2)
 
-foreign import data AVAR :: !
+import Unsafe.Coerce (unsafeCoerce)
 
-foreign import data AVar :: * -> *
+foreign import data AVAR :: !
 
 type AffAVar e a = Aff (avar :: AVAR | e) a
 
 -- | Makes a new asynchronous avar.
 makeVar :: forall e a. AffAVar e (AVar a)
-makeVar = _makeVar nonCanceler
+makeVar = fromAVBox $ _makeVar nonCanceler
 
 -- | Makes a avar and sets it to some value.
 makeVar' :: forall e a. a -> AffAVar e (AVar a)
@@ -37,25 +39,20 @@ makeVar' a = do
 
 -- | Takes the next value from the asynchronous avar.
 takeVar :: forall e a. AVar a -> AffAVar e a
-takeVar q = runFn2 _takeVar nonCanceler q
+takeVar q = fromAVBox $ runFn2 _takeVar nonCanceler q
 
 -- | Puts a new value into the asynchronous avar. If the avar has
 -- | been killed, this will result in an error.
 putVar :: forall e a. AVar a -> a -> AffAVar e Unit
-putVar q a = runFn3 _putVar nonCanceler q a
+putVar q a = fromAVBox $ runFn3 _putVar nonCanceler q a
 
 -- | Modifies the value at the head of the avar (will suspend until one is available).
 modifyVar :: forall e a. (a -> a) -> AVar a -> AffAVar e Unit
 modifyVar f v = takeVar v >>= (f >>> putVar v)
 
 -- | Kills an asynchronous avar.
 killVar :: forall e a. AVar a -> Error -> AffAVar e Unit
-killVar q e = runFn3 _killVar nonCanceler q e
-
-foreign import _makeVar :: forall e a. Canceler e -> AffAVar e (AVar a)
-
-foreign import _takeVar :: forall e a. Fn2 (Canceler e) (AVar a) (AffAVar e a)
-
-foreign import _putVar :: forall e a. Fn3 (Canceler e) (AVar a) a (AffAVar e Unit)
+killVar q e = fromAVBox $ runFn3 _killVar nonCanceler q e
 
-foreign import _killVar :: forall e a. Fn3 (Canceler e) (AVar a) Error (AffAVar e Unit)
+fromAVBox :: forall a e. AVBox a -> AffAVar e a
+fromAVBox = unsafeCoerce

src/Control/Monad/Aff/AVar.js renamed to src/Control/Monad/Aff/Internal.js

@@ -0,0 +1,26 @@
+module Control.Monad.Aff.Internal
+  ( AVBox
+  , AVar
+  , _makeVar
+  , _takeVar
+  , _putVar
+  , _killVar
+  ) where
+
+import Prelude
+
+import Control.Monad.Eff.Exception (Error)
+
+import Data.Function.Uncurried (Fn2, Fn3)
+
+foreign import data AVar :: * -> *
+
+foreign import data AVBox :: * -> *
+
+foreign import _makeVar :: forall c a. c -> AVBox (AVar a)
+
+foreign import _takeVar :: forall c a. Fn2 c (AVar a) (AVBox a)
+
+foreign import _putVar :: forall c a. Fn3 c (AVar a) a (AVBox Unit)
+
+foreign import _killVar :: forall c a. Fn3 c (AVar a) Error (AVBox Unit)