Merge pull request #1 from natefaubion/impl

Initial implementation

Author: natefaubion

.gitignore

@@ -6,3 +6,5 @@ node_modules
 # Generated files
 .psci
 output
+
+.psc-ide-port

.travis.yml

@@ -0,0 +1,17 @@
+language: node_js
+dist: trusty
+sudo: required
+node_js: stable
+install:
+  - npm install -g bower
+  - npm install
+script:
+  - bower install --production
+  - npm run -s build
+  - bower install
+  - npm -s test
+after_success:
+- >-
+  test $TRAVIS_TAG &&
+  echo $GITHUB_TOKEN | pulp login &&
+  echo y | pulp publish --no-push

bower.json

@@ -0,0 +1,34 @@
+{
+  "name": "purescript-avar",
+  "homepage": "https://github.com/slamdata/purescript-avar",
+  "authors": [
+    "Nathan Faubion <[email protected]>"
+  ],
+  "description": "Low-level interface for asynchronous variables",
+  "main": "",
+  "keywords": [
+    "PureScript",
+    "AVar"
+  ],
+  "license": "Apache-2.0",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ],
+  "dependencies": {
+    "purescript-eff": "^3.1.0",
+    "purescript-maybe": "^3.0.0",
+    "purescript-either": "^3.1.0",
+    "purescript-functions": "^3.0.0",
+    "purescript-exceptions": "^3.0.0"
+  },
+  "devDependencies": {
+    "purescript-assert": "^3.0.0",
+    "purescript-console": "^3.0.0",
+    "purescript-transformers": "^3.4.0",
+    "purescript-refs": "^3.0.0"
+  }
+}

package.json

@@ -0,0 +1,15 @@
+{
+  "private": true,
+  "scripts": {
+    "clean": "rimraf output && rimraf .pulp-cache",
+    "build": "jshint src --verbose && pulp build -- --censor-lib --strict",
+    "test": "pulp test"
+  },
+  "devDependencies": {
+    "jshint": "^2.9.5",
+    "pulp": "^11.0.0",
+    "purescript-psa": "^0.5.1",
+    "purescript": "^0.11.5",
+    "rimraf": "^2.6.1"
+  }
+}

src/Control/Monad/Eff/AVar.js

@@ -0,0 +1,296 @@
+/* globals exports, setTimeout */
+/* jshint -W097 */
+
+"use strict";
+
+var EMPTY = {};
+
+function MutableQueue () {
+  this.head = null;
+  this.last = null;
+  this.size = 0;
+}
+
+function MutableCell (queue, value) {
+  this.queue = queue;
+  this.value = value;
+  this.next  = null;
+  this.prev  = null;
+}
+
+function putLast (queue, value) {
+  var cell = new MutableCell(queue, value);
+  switch (queue.size) {
+  case 0:
+    queue.head = cell;
+    break;
+  case 1:
+    cell.prev = queue.head;
+    queue.head.next = cell;
+    queue.last = cell;
+    break;
+  default:
+    cell.prev = queue.last;
+    queue.last.next = cell;
+    queue.last = cell;
+  }
+  queue.size++;
+  return cell;
+}
+
+function takeLast (queue) {
+  var cell;
+  switch (queue.size) {
+  case 0:
+    return null;
+  case 1:
+    cell = queue.head;
+    queue.head = null;
+    break;
+  case 2:
+    cell = queue.last;
+    queue.head.next = null;
+    queue.last = null;
+    break;
+  default:
+    cell = queue.last;
+    queue.last = cell.prev;
+    queue.last.next = null;
+  }
+  cell.prev = null;
+  cell.queue = null;
+  queue.size--;
+  return cell.value;
+}
+
+function takeHead (queue) {
+  var cell;
+  switch (queue.size) {
+  case 0:
+    return null;
+  case 1:
+    cell = queue.head;
+    queue.head = null;
+    break;
+  case 2:
+    cell = queue.head;
+    queue.last.prev = null;
+    queue.head = queue.last;
+    queue.last = null;
+    break;
+  default:
+    cell = queue.head;
+    queue.head = cell.next;
+    queue.head.prev = null;
+  }
+  cell.next = null;
+  cell.queue = null;
+  queue.size--;
+  return cell.value;
+}
+
+function deleteCell (cell) {
+  if (cell.queue === null) {
+    return;
+  }
+  if (cell.queue.last === cell) {
+    takeLast(cell.queue);
+    return;
+  }
+  if (cell.queue.head === cell) {
+    takeHead(cell.queue);
+    return;
+  }
+  if (cell.prev) {
+    cell.prev.next = cell.next;
+  }
+  if (cell.next) {
+    cell.next.prev = cell.prev;
+  }
+  cell.queue.size--;
+  cell.queue = null;
+  cell.value = null;
+  cell.next  = null;
+  cell.prev  = null;
+}
+
+function AVar (value) {
+  this.draining = false;
+  this.error    = null;
+  this.value    = value;
+  this.takes    = new MutableQueue();
+  this.reads    = new MutableQueue();
+  this.puts     = new MutableQueue();
+}
+
+exports.makeEmptyVar = function () {
+  return new AVar(EMPTY);
+};
+
+exports.makeVar = function (value) {
+  return function () {
+    return new AVar(value);
+  };
+};
+
+exports._killVar = function (left, right, avar, error) {
+  return function () {
+    if (avar.error === null) {
+      avar.error = error;
+      avar.value = EMPTY;
+      drainVar(left, right, avar);
+    }
+  };
+};
+
+exports._putVar = function (left, right, avar, value, cb) {
+  return function () {
+    var cell = putLast(avar.puts, { cb: cb, value: value });
+    drainVar(left, right, avar);
+    return function () {
+      deleteCell(cell);
+    };
+  };
+};
+
+exports._takeVar = function (left, right, avar, cb) {
+  return function () {
+    var cell = putLast(avar.takes, cb);
+    drainVar(left, right, avar);
+    return function () {
+      deleteCell(cell);
+    };
+  };
+};
+
+exports._readVar = function (left, right, avar, cb) {
+  return function () {
+    var cell = putLast(avar.reads, cb);
+    drainVar(left, right, avar);
+    return function () {
+      deleteCell(cell);
+    };
+  };
+};
+
+exports._tryPutVar = function (left, right, avar, value) {
+  return function () {
+    if (avar.value === EMPTY && avar.error === null) {
+      avar.value = value;
+      drainVar(left, right, avar);
+      return true;
+    } else {
+      return false;
+    }
+  };
+};
+
+exports._tryTakeVar = function (left, right, nothing, just, avar) {
+  return function () {
+    var value = avar.value;
+    if (value === EMPTY) {
+      return nothing;
+    } else {
+      avar.value = EMPTY;
+      drainVar(left, right, avar);
+      return just(value);
+    }
+  };
+};
+
+exports._tryReadVar = function (nothing, just, avar) {
+  return function () {
+    if (avar.value === EMPTY) {
+      return nothing;
+    } else {
+      return just(avar.value);
+    }
+  };
+};
+
+exports.isEmptyVar = function (avar) {
+  return function () {
+    return avar.value === EMPTY;
+  };
+};
+
+function drainVar (left, right, avar) {
+  if (avar.draining) {
+    return;
+  }
+
+  var ps = avar.puts;
+  var ts = avar.takes;
+  var rs = avar.reads;
+  var p, r, t, value, rsize;
+
+  avar.draining = true;
+
+  /* jshint -W084 */
+  while (1) {
+    p = null;
+    r = null;
+    t = null;
+    value = avar.value;
+    rsize = rs.size;
+
+    if (avar.error !== null) {
+      value = left(avar.error);
+      while (p = takeHead(ps)) {
+        runEff(p.cb(value));
+      }
+      while (r = takeHead(rs)) {
+        runEff(r(value));
+      }
+      while (t = takeHead(ts)) {
+        runEff(t(value));
+      }
+      break;
+    }
+
+    // Process the next put. We do not immediately invoke the callback
+    // because we want to preserve ordering. If there are takes/reads
+    // we want to run those first.
+    if (value === EMPTY && (p = takeHead(ps))) {
+      avar.value = value = p.value;
+    }
+
+    if (value !== EMPTY) {
+      // We go ahead and queue up the next take for the same reasons as
+      // above. Invoking the read callbacks can affect the mutable queue.
+      t = takeHead(ts);
+      // 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)));
+      }
+      if (t !== null) {
+        avar.value = EMPTY;
+        runEff(t(right(value)));
+      }
+    }
+
+    if (p !== null) {
+      runEff(p.cb(right(void 0)));
+    }
+
+    // Callbacks could have queued up more items so we need to guard on the
+    // actual mutable properties.
+    if (avar.value === EMPTY && ps.size === 0 || avar.value !== EMPTY && ts.size === 0) {
+      break;
+    }
+  }
+  /* jshint +W084 */
+
+  avar.draining = false;
+}
+
+function runEff(eff) {
+  try {
+    eff();
+  } catch (error) {
+    setTimeout(function () {
+      throw error;
+    }, 0);
+  }
+}