Merge pull request #3 from natefaubion/arg-order

Argument order, status

Author: natefaubion

src/Control/Monad/Eff/AVar.js

@@ -133,88 +133,94 @@ exports.makeVar = function (value) {
   };
 };
 
-exports._killVar = function (left, right, avar, error) {
+exports._killVar = function (util, error, avar) {
   return function () {
     if (avar.error === null) {
       avar.error = error;
       avar.value = EMPTY;
-      drainVar(left, right, avar);
+      drainVar(util, avar);
     }
   };
 };
 
-exports._putVar = function (left, right, avar, value, cb) {
+exports._putVar = function (util, value, avar, cb) {
   return function () {
     var cell = putLast(avar.puts, { cb: cb, value: value });
-    drainVar(left, right, avar);
+    drainVar(util, avar);
     return function () {
       deleteCell(cell);
     };
   };
 };
 
-exports._takeVar = function (left, right, avar, cb) {
+exports._takeVar = function (util, avar, cb) {
   return function () {
     var cell = putLast(avar.takes, cb);
-    drainVar(left, right, avar);
+    drainVar(util, avar);
     return function () {
       deleteCell(cell);
     };
   };
 };
 
-exports._readVar = function (left, right, avar, cb) {
+exports._readVar = function (util, avar, cb) {
   return function () {
     var cell = putLast(avar.reads, cb);
-    drainVar(left, right, avar);
+    drainVar(util, avar);
     return function () {
       deleteCell(cell);
     };
   };
 };
 
-exports._tryPutVar = function (left, right, avar, value) {
+exports._tryPutVar = function (util, value, avar) {
   return function () {
     if (avar.value === EMPTY && avar.error === null) {
       avar.value = value;
-      drainVar(left, right, avar);
+      drainVar(util, avar);
       return true;
     } else {
       return false;
     }
   };
 };
 
-exports._tryTakeVar = function (left, right, nothing, just, avar) {
+exports._tryTakeVar = function (util, avar) {
   return function () {
     var value = avar.value;
     if (value === EMPTY) {
-      return nothing;
+      return util.nothing;
     } else {
       avar.value = EMPTY;
-      drainVar(left, right, avar);
-      return just(value);
+      drainVar(util, avar);
+      return util.just(value);
     }
   };
 };
 
-exports._tryReadVar = function (nothing, just, avar) {
+exports._tryReadVar = function (util, avar) {
   return function () {
     if (avar.value === EMPTY) {
-      return nothing;
+      return util.nothing;
     } else {
-      return just(avar.value);
+      return util.just(avar.value);
     }
   };
 };
 
-exports.isEmptyVar = function (avar) {
+exports._status = function (util, avar) {
   return function () {
-    return avar.value === EMPTY;
+    if (avar.error) {
+      return util.killed(avar.error);
+    }
+    if (avar.value === EMPTY) {
+      return util.empty;
+    }
+    return util.filled(avar.value);
   };
 };
 
-function drainVar (left, right, avar) {
+function drainVar (util, avar) {
   if (avar.draining) {
     return;
   }
@@ -235,7 +241,7 @@ function drainVar (left, right, avar) {
     rsize = rs.size;
 
     if (avar.error !== null) {
-      value = left(avar.error);
+      value = util.left(avar.error);
       while (p = takeHead(ps)) {
         runEff(p.cb(value));
       }
@@ -262,16 +268,16 @@ function drainVar (left, right, avar) {
       // We only want to process the reads queued up before running these
       // callbacks so we guard on rsize.
       while (rsize-- && (r = takeHead(rs))) {
-        runEff(r(right(value)));
+        runEff(r(util.right(value)));
       }
       if (t !== null) {
         avar.value = EMPTY;
-        runEff(t(right(value)));
+        runEff(t(util.right(value)));
       }
     }
 
     if (p !== null) {
-      runEff(p.cb(right(void 0)));
+      runEff(p.cb(util.right(void 0)));
     }
 
     // Callbacks could have queued up more items so we need to guard on the

src/Control/Monad/Eff/AVar.purs

@@ -3,16 +3,23 @@ module Control.Monad.Eff.AVar
   , AVAR
   , AVarEff
   , AVarCallback
+  , AVarStatus(..)
   , makeVar
   , makeEmptyVar
-  , isEmptyVar
   , takeVar
   , tryTakeVar
   , putVar
   , tryPutVar
   , readVar
   , tryReadVar
   , killVar
+  , status
+  , isEmptyVar
+  , isFilledVar
+  , isKilledVar
+  , isEmpty
+  , isFilled
+  , isKilled
   ) where
 
 import Prelude
@@ -30,59 +37,114 @@ foreign import data AVar ∷ Type → Type
 
 foreign import data AVAR ∷ Effect
 
+data AVarStatus a
+  = Killed Error
+  | Filled a
+  | Empty
+
 -- | Creates a fresh AVar.
 foreign import makeEmptyVar ∷ ∀ eff a. AVarEff eff (AVar a)
 
 -- | Creates a fresh AVar with an initial value.
 foreign import makeVar ∷ ∀ eff a. a → AVarEff eff (AVar a)
 
--- | Synchronously checks whether an AVar currently has a value.
-foreign import isEmptyVar ∷ ∀ eff a. AVar a → AVarEff eff Boolean
-
 -- | Kills the AVar with an exception. All pending and future actions will
 -- | resolve immediately with the provided exception.
-killVar ∷ ∀ eff a. AVar a → Error → AVarEff eff Unit
-killVar avar err = Fn.runFn4 _killVar Left Right avar err
+killVar ∷ ∀ eff a. Error → AVar a → AVarEff eff Unit
+killVar err avar = Fn.runFn3 _killVar ffiUtil err avar
 
 -- | Sets the value of the AVar. If the AVar is already filled, it will be
 -- | queued until the value is emptied. Multiple puts will resolve in order as
 -- | the AVar becomes available. Returns an effect which will remove the
 -- | callback from the pending queue.
-putVar ∷ ∀ eff a. AVar a → a → AVarCallback eff Unit → AVarEff eff (AVarEff eff Unit)
-putVar avar value cb = Fn.runFn5 _putVar Left Right avar value cb
+putVar ∷ ∀ eff a. a → AVar a → AVarCallback eff Unit → AVarEff eff (AVarEff eff Unit)
+putVar value avar cb = Fn.runFn4 _putVar ffiUtil value avar cb
 
 -- | Attempts to synchronously fill an AVar. If the AVar is already filled,
 -- | this will do nothing. Returns true or false depending on if it succeeded.
-tryPutVar ∷ ∀ eff a. AVar a → a → AVarEff eff Boolean
-tryPutVar avar value = Fn.runFn4 _tryPutVar Left Right avar value
+tryPutVar ∷ ∀ eff a. a → AVar a → AVarEff eff Boolean
+tryPutVar value avar = Fn.runFn3 _tryPutVar ffiUtil value avar
 
 -- | Takes the AVar value, leaving it empty. If the AVar is already empty,
 -- | the callback will be queued until the AVar is filled. Multiple takes will
 -- | resolve in order as the AVar fills. Returns an effect which will remove
 -- | the callback from the pending queue.
 takeVar ∷ ∀ eff a. AVar a → AVarCallback eff a → AVarEff eff (AVarEff eff Unit)
-takeVar avar cb = Fn.runFn4 _takeVar Left Right avar cb
+takeVar avar cb = Fn.runFn3 _takeVar ffiUtil avar cb
 
 -- | Attempts to synchronously take an AVar value, leaving it empty. If the
 -- | AVar is empty, this will return `Nothing`.
 tryTakeVar ∷ ∀ eff a. AVar a → AVarEff eff (Maybe a)
-tryTakeVar avar = Fn.runFn5 _tryTakeVar Left Right Nothing Just avar
+tryTakeVar avar = Fn.runFn2 _tryTakeVar ffiUtil avar
 
 -- | Reads the AVar value. Unlike `takeVar`, this will not leave the AVar empty.
 -- | If the AVar is empty, this will queue until it is filled. Multiple reads
 -- | will resolve at the same time, as soon as possible.
 readVar ∷ ∀ eff a. AVar a → AVarCallback eff a → AVarEff eff (AVarEff eff Unit)
-readVar avar cb = Fn.runFn4 _readVar Left Right avar cb
+readVar avar cb = Fn.runFn3 _readVar ffiUtil avar cb
 
 -- | Attempts to synchronously read an AVar. If the AVar is empty, this will
 -- | return `Nothing`.
 tryReadVar ∷ ∀ eff a. AVar a → AVarEff eff (Maybe a)
-tryReadVar avar = Fn.runFn3 _tryReadVar Nothing Just avar
-
-foreign import _killVar ∷ ∀ eff a. Fn.Fn4 (∀ x y. x → Either x y) (∀ x y. y → Either x y) (AVar a) Error (AVarEff eff Unit)
-foreign import _putVar ∷ ∀ eff a. Fn.Fn5 (∀ x y. x → Either x y) (∀ x y. y → Either x y) (AVar a) a (AVarCallback eff Unit) (AVarEff eff (AVarEff eff Unit))
-foreign import _tryPutVar ∷ ∀ eff a. Fn.Fn4 (∀ x y. x → Either x y) (∀ x y. y → Either x y) (AVar a) a (AVarEff eff Boolean)
-foreign import _takeVar ∷ ∀ eff a. Fn.Fn4 (∀ x y. x → Either x y) (∀ x y. y → Either x y) (AVar a) (AVarCallback eff a) (AVarEff eff (AVarEff eff Unit))
-foreign import _tryTakeVar ∷ ∀ eff a. Fn.Fn5 (∀ x y. x → Either x y) (∀ x y. y → Either x y) (Maybe a) (a → Maybe a) (AVar a) (AVarEff eff (Maybe a))
-foreign import _readVar ∷ ∀ eff a. Fn.Fn4 (∀ x y. x → Either x y) (∀ x y. y → Either x y) (AVar a) (AVarCallback eff a) (AVarEff eff (AVarEff eff Unit))
-foreign import _tryReadVar ∷ ∀ eff a. Fn.Fn3 (Maybe a) (a → Maybe a) (AVar a) (AVarEff eff (Maybe a))
+tryReadVar avar = Fn.runFn2 _tryReadVar ffiUtil avar
+
+-- | Synchronously checks the status of an AVar.
+status ∷ ∀ eff a. AVar a → AVarEff eff (AVarStatus a)
+status avar = Fn.runFn2 _status ffiUtil avar
+
+-- | Synchronously checks whether an AVar currently is empty.
+isEmptyVar ∷ ∀ eff a. AVar a → AVarEff eff Boolean
+isEmptyVar = map isEmpty <<< status
+
+-- | Synchronously checks whether an AVar currently has a value.
+isFilledVar ∷ ∀ eff a. AVar a → AVarEff eff Boolean
+isFilledVar = map isFilled <<< status
+
+-- | Synchronously checks whether an AVar has been killed.
+isKilledVar ∷ ∀ eff a. AVar a → AVarEff eff Boolean
+isKilledVar = map isKilled <<< status
+
+isEmpty ∷ ∀ a. AVarStatus a → Boolean
+isEmpty = case _ of
+  Empty → true
+  _ → false
+
+isFilled ∷ ∀ a. AVarStatus a → Boolean
+isFilled = case _ of
+  Filled _ → true
+  _ → false
+
+isKilled ∷ ∀ a. AVarStatus a → Boolean
+isKilled = case _ of
+  Killed _ → true
+  _ → false
+
+foreign import _killVar ∷ ∀ eff a. Fn.Fn3 FFIUtil Error (AVar a) (AVarEff eff Unit)
+foreign import _putVar ∷ ∀ eff a. Fn.Fn4 FFIUtil a (AVar a) (AVarCallback eff Unit) (AVarEff eff (AVarEff eff Unit))
+foreign import _tryPutVar ∷ ∀ eff a. Fn.Fn3 FFIUtil a (AVar a) (AVarEff eff Boolean)
+foreign import _takeVar ∷ ∀ eff a. Fn.Fn3 FFIUtil (AVar a) (AVarCallback eff a) (AVarEff eff (AVarEff eff Unit))
+foreign import _tryTakeVar ∷ ∀ eff a. Fn.Fn2 FFIUtil (AVar a) (AVarEff eff (Maybe a))
+foreign import _readVar ∷ ∀ eff a. Fn.Fn3 FFIUtil (AVar a) (AVarCallback eff a) (AVarEff eff (AVarEff eff Unit))
+foreign import _tryReadVar ∷ ∀ eff a. Fn.Fn2 FFIUtil (AVar a) (AVarEff eff (Maybe a))
+foreign import _status ∷ ∀ eff a. Fn.Fn2 FFIUtil (AVar a) (AVarEff eff (AVarStatus a))
+
+type FFIUtil =
+  { left ∷ ∀ a b. a → Either a b
+  , right ∷ ∀ a b. b → Either a b
+  , nothing ∷ ∀ a. Maybe a
+  , just ∷ ∀ a. a → Maybe a
+  , killed ∷ ∀ a. Error → AVarStatus a
+  , filled ∷ ∀ a. a → AVarStatus a
+  , empty ∷ ∀ a. AVarStatus a
+  }
+
+ffiUtil ∷ FFIUtil
+ffiUtil =
+  { left: Left
+  , right: Right
+  , nothing: Nothing
+  , just: Just
+  , killed: Killed
+  , filled: Filled
+  , empty: Empty
+  }