@mfjs/compiler/builder.js

// Generated by CoffeeScript 1.10.0
(function() {
  var $debId, BlockEff, BlockPure, Builder, CAPTURE_SET, Cont, Eff, Empty, ExprEff, ExprPure, Par, Postfix, PurePrefix, VarUsage, assert, config, envBefore, envMerge, envPush, envThread, kit, root,
    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    hasProp = {}.hasOwnProperty,
    slice = [].slice;

  kit = require("./kit");

  config = require("./config");

  root = module.exports = {};

  assert = require("assert");

  CAPTURE_SET = true;

  VarUsage = (function() {
    function VarUsage() {
      this.sets = {};
      this.upds = {};
      this.mods = {};
      this.uses = {};
      this.after = {};
      this.before = {};
      this.vars = {};
    }

    VarUsage.prototype.init = function() {
      var deps, i, ref, v, w;
      deps = {};
      ref = this.vars;
      for (i in ref) {
        v = ref[i];
        if (!(v && !this.refs[i])) {
          continue;
        }
        w = deps[i] = {};
        if (!this.after[i]) {
          w.fin = true;
        }
        if (this.uses[i]) {
          w.use = true;
        }
        if (this.sets[i]) {
          if (this.before[i]) {
            w.mod = true;
          } else {
            w.set = true;
          }
        }
        if (this.upds[i]) {
          w.use = w.mod = true;
        }
      }
      return deps;
    };

    VarUsage.prototype.setBefore = function(known) {
      var i, results;
      results = [];
      for (i in known) {
        this.before[i] = true;
        if (this.sets[i]) {
          this.sets[i] = false;
          results.push(this.upds[i] = true);
        } else {
          results.push(void 0);
        }
      }
      return results;
    };

    VarUsage.prototype.addAssign = function(name) {
      if (this.uses[name]) {
        this.upds[name] = true;
      } else {
        this.sets[name] = true;
      }
      this.mods[name] = true;
      this.mod = true;
      return this;
    };

    VarUsage.prototype.addUpd = function(name) {
      this.upds[name] = true;
      this.uses[name] = true;
      this.mods[name] = true;
      this.mod = true;
      this.upd = true;
      return this;
    };

    VarUsage.prototype.skipMods = function() {
      this._skipMods = true;
      return this;
    };

    VarUsage.prototype.addInner = function(d) {
      var i, ref, ref1, v;
      if (d.mod) {
        this.mod = true;
      }
      if (d.upd) {
        this.upd = true;
      }
      if (!this._skipMods) {
        ref = d.mods;
        for (i in ref) {
          v = ref[i];
          if (v) {
            this.mods[i] = true;
          }
        }
      }
      ref1 = d.uses;
      for (i in ref1) {
        v = ref1[i];
        if (v) {
          this.uses[i] = true;
        }
      }
    };

    VarUsage.prototype.addInnerDeep = function(d) {
      var i, ref, ref1, ref2, v;
      this.addInner(d);
      if (d.mod) {
        this.mod = true;
      }
      if (d.upd) {
        this.upd = true;
      }
      ref = d.upds;
      for (i in ref) {
        v = ref[i];
        if (v) {
          this.upds[i] = true;
        }
      }
      ref1 = d.uses;
      for (i in ref1) {
        v = ref1[i];
        if (v) {
          this.uses[i] = true;
        }
      }
      ref2 = d.sets;
      for (i in ref2) {
        v = ref2[i];
        if (v) {
          if (this.uses[i]) {
            this.upds[i] = true;
            this.upd = true;
          } else {
            this.sets[i] = true;
          }
        }
      }
    };

    VarUsage.prototype.threadOutMap = function(res) {
      var i, ref, v;
      if (res == null) {
        res = {};
      }
      ref = this.mods;
      for (i in ref) {
        v = ref[i];
        if (!(v)) {
          continue;
        }
        if (!this.after[i]) {
          continue;
        }
        if (!(this.vars[i] && !this.refs[i])) {
          continue;
        }
        res[i] = true;
      }
      return res;
    };

    return VarUsage;

  })();

  envPush = function(dst, src) {
    var i, v, w;
    for (i in src) {
      v = src[i];
      w = dst[i] != null ? dst[i] : dst[i] = {};
      if (v.mod || v.set && w.use) {
        w.mod = true;
      }
      if (v.use) {
        w.use = true;
      }
      if (v.set && !w.mod) {
        w.set = true;
      }
      if (v.fin) {
        w.fin = true;
      }
      if (v.thread && !v.fin) {
        w.thread = true;
      }
    }
    return dst;
  };

  envMerge = function(dst, src) {
    var i, v, w;
    for (i in src) {
      v = src[i];
      w = dst[i] != null ? dst[i] : dst[i] = {};
      if (v.use) {
        w.use = true;
      }
      if (v.mod) {
        w.mod = true;
      }
      if (v.fin) {
        w.fin = true;
      }
      if (v.thread && !v.fin) {
        w.thread = true;
      }
    }
    return dst;
  };

  envThread = function(env) {
    var i, v;
    return ((function() {
      var results;
      results = [];
      for (i in env) {
        v = env[i];
        if (v.thread && !v.fin) {
          results.push(i);
        }
      }
      return results;
    })()).sort().map(kit.id);
  };

  envBefore = function(f, s) {
    var i, v, w;
    for (i in s) {
      v = s[i];
      if ((w = f[i]) && w.use) {
        v.use = true;
      }
    }
  };

  root.VarUsage = VarUsage;

  $debId = 0;

  Builder = (function() {
    function Builder() {
      this.env = {};
      this.opts = {};
      this.$debId = $debId++;
    }

    Builder.prototype.setOpts = function(opts) {
      var i, o, v;
      o = this.opts;
      if (o != null) {
        for (i in opts) {
          v = opts[i];
          if (o[i] == null) {
            o[i] = v;
          }
        }
      } else {
        this.opts = opts;
      }
      return this;
    };

    Builder.prototype.needCoerce = function(v) {
      if (v == null) {
        v = true;
      }
      this._needCoerce = v;
      return this;
    };

    Builder.prototype.coerceObj = function() {
      if (!this._needCoerce) {
        return this;
      }
      return this.toExprBuilder()._coerceObj();
    };

    Builder.prototype._coerceObj = function() {
      return this;
    };

    Builder.prototype.noCoerceTry = function() {
      this._noCoerceTry = true;
      return this;
    };

    Builder.prototype.coerceTry = function() {
      var b;
      if (this._noCoerceTry && this.opts.coerce === "all") {
        return this;
      }
      b = this.capture().toBlockBuilder();
      return root.expr(kit.coerceThunk(b.block), b.eff).morph(b).noCoerceTry();
    };

    Builder.prototype.setBindVar = function(bv) {
      if (bv === false) {
        delete this._bindvar;
        return this;
      }
      if (bv != null) {
        this._bindVar = bv;
      }
      return this;
    };

    Builder.prototype.getBindVar = function() {
      return this._bindVar;
    };

    Builder.prototype.noCapture = function() {
      this._captured = true;
      return this;
    };

    Builder.prototype.capture = function() {
      if (this._captured) {
        return this;
      }
      this._captured = true;
      return this._capture();
    };

    Builder.prototype._capture = function() {
      return this;
    };

    Builder.prototype.morph = function(other, env) {
      var brk;
      this.setBindVar(other.getBindVar());
      assert.ok(other.opts);
      this.opts = other.opts;
      if (this._captured == null) {
        this._captured = other._captured;
      }
      if (env == null) {
        env = other.env;
      }
      if (env) {
        envPush(this.env, env);
      }
      brk = other.isBrk();
      if (brk != null) {
        this.setBrk(brk);
      }
      if (this._needCoerce == null) {
        this._needCoerce = other._needCoerce;
      }
      return this;
    };

    Builder.prototype.toBlockBuilder = function(eff) {
      var block, n;
      n = this.toExprBuilder(eff);
      block = [kit.ret(n.expr)];
      return (n.eff ? root.blockEff(block) : root.pureBlock(block)).morph(n);
    };

    Builder.prototype.toExprBuilder = function(eff) {
      var expr, n;
      assert.ok(this.toBlockBuilder !== Builder.prototype.toBlockBuilder);
      n = this.toBlockBuilder(eff);
      expr = kit.call(kit.fun([], n.block), []);
      return (n.eff ? root.exprEff(expr) : root.exprPure(expr)).morph(n);
    };

    Builder.prototype.toBlock = function(eff) {
      return this.capture().toBlockBuilder(eff).block;
    };

    Builder.prototype.toExpr = function(eff) {
      return this.capture().toExprBuilder(eff).expr;
    };

    Builder.prototype.pushEnv = function(env) {
      envPush(this.env, env);
      return this;
    };

    Builder.prototype.mergeEnv = function(env) {
      envPush(this.env, env.init());
      return this;
    };

    Builder.prototype.bindTo = function() {
      var base, block, bv, capt, captVars, closVars, cont, eff, env, exprs, i, j, k, l, len, len1, lhs, ref, ref1, ref2, thisCapt, threadIn, threadOut, threadVars, tvars, v, vars, w, x;
      vars = [];
      exprs = [];
      eff = false;
      assert.ok(arguments.length);
      for (k = 0, len = arguments.length; k < len; k++) {
        i = arguments[k];
        eff || (eff = i.eff);
      }
      env = {};
      threadVars = [];
      captVars = {};
      threadIn = {};
      lhs = {};
      for (x = l = 0, len1 = arguments.length; l < len1; x = ++l) {
        i = arguments[x];
        capt = i;
        if (arguments.length === 1) {
          capt = capt.coerceObj();
        }
        capt = capt.capture().toExprBuilder(eff);
        tvars = [];
        ref = capt.env;
        for (j in ref) {
          v = ref[j];
          w = env[j] != null ? env[j] : env[j] = {};
          if (v.use) {
            w.use = true;
          }
          if (v.mod || w.use && v.set) {
            w.mod = true;
          }
          if (v.set && !w.mod) {
            w.set = true;
          }
          if (v.fin) {
            w.fin = true;
          }
          if (v.thread && !v.fin) {
            w.thread = true;
            threadIn[j] = true;
            tvars.push(j);
          }
        }
        if (tvars.length !== 0) {
          assert.ok(arguments.length === 1);
        }
        threadVars.push.apply(threadVars, tvars);
        exprs.push(capt.expr);
        bv = capt.getBindVar();
        if (bv != null) {
          vars.push(bv);
        }
        vars.push.apply(vars, tvars.sort().map(kit.id));
      }
      threadOut = {};
      for (i in env) {
        v = env[i];
        w = (ref1 = this.env[i]) != null ? ref1 : {};
        if (!v.fin && (v.thread || v.mod || w.mod)) {
          threadOut[i] = true;
        }
      }
      thisCapt = this.addThread(threadOut).capture();
      block = thisCapt.toBlock();
      if (this.isBrk()) {
        thisCapt.setBrk(true);
      }
      closVars = [];
      ref2 = thisCapt.env;
      for (i in ref2) {
        v = ref2[i];
        if (!v.mod) {
          continue;
        }
        v.mod = false;
        if (!threadIn[i]) {
          closVars.push(i);
        }
      }
      closVars = closVars.sort().map(kit.id);
      if (closVars.length) {
        block = [kit.ret(kit.call(kit.fun(closVars, block), closVars))];
      }
      for (i in env) {
        v = env[i];
        if (!v.mod) {
          continue;
        }
        w = (base = thisCapt.env)[i] != null ? base[i] : base[i] = {
          fin: true
        };
        w.use = w.mod = true;
      }
      cont = kit.fun(vars, block);
      if (exprs.length === 0) {
        return thisCapt;
      }
      return root.exprEffCaptured(thisCapt.mkMap(exprs, cont)).needCoerce(false).morph(thisCapt);
    };

    Builder.prototype.setBrk = function(brk1) {
      this.brk = brk1;
      return this;
    };

    Builder.prototype.isBrk = function() {
      return this.brk;
    };

    Builder.prototype.addThread = function(thread) {
      var any, base, base1, env, i, ref, some, v, w;
      if (this.isBrk()) {
        for (i in thread) {
          v = thread[i];
          (w = (base = this.env)[i] != null ? base[i] : base[i] = {
            fin: true
          }).thread = true;
        }
        this;
      }
      if (!this._captured) {
        for (i in thread) {
          v = thread[i];
          if (v) {
            (w = (base1 = this.env)[i] != null ? base1[i] : base1[i] = {
              fin: true
            }).thread = true;
          }
        }
        return this;
      }
      env = {};
      if (thread != null) {
        for (i in thread) {
          v = thread[i];
          if (!(v)) {
            continue;
          }
          w = this.env[i];
          if ((w != null) && w.fin) {
            continue;
          }
          (env[i] = {}).thread = true;
          if ((w != null) && !w.thread) {
            any = true;
          }
        }
        ref = this.env;
        for (i in ref) {
          v = ref[i];
          if (!(!v.fin)) {
            continue;
          }
          w = env[i] != null ? env[i] : env[i] = {};
          if (v.thread && !thread[i]) {
            some = true;
            w.thread = true;
          }
        }
      }
      if (!any) {
        return this;
      }
      return root.purePostfix(this, root.pure([]).pushEnv(env)).morph(this);
    };

    return Builder;

  })();

  BlockPure = (function(superClass) {
    extend(BlockPure, superClass);

    function BlockPure(block1) {
      this.block = block1;
      BlockPure.__super__.constructor.call(this);
    }

    BlockPure.prototype.mkMap = function(args, fun) {
      return kit.mapply(args, fun);
    };

    BlockPure.prototype.pureBlock = function() {
      return this.block;
    };

    BlockPure.prototype.toPrefix = function() {
      return this;
    };

    BlockPure.prototype.toBlockBuilder = function(eff) {
      var block, expr, nocoerce;
      block = this.block;
      expr = this.ret;
      nocoerce = this.opts.coerce === "none";
      if (expr != null) {
        if (eff && nocoerce) {
          expr = kit.pure(expr);
        }
        block.push(kit.ret(expr));
      }
      if (!eff) {
        return this.needCoerce(!nocoerce);
      }
      if (!expr) {
        if (nocoerce) {
          block.push(kit.ret(kit.pure()));
        }
      }
      return root.blockEff(block).morph(this).needCoerce(!nocoerce);
    };

    BlockPure.prototype.prepend = function(other) {
      return (this.opts.bindAssoc === "left" ? root.postfixLeft(other, this) : root.purePostfix(other, this)).setOpts(this.opts);
    };

    BlockPure.prototype._append = function(other) {
      var ref;
      if (other.pureBlock != null) {
        (ref = this.block).push.apply(ref, other.pureBlock());
        envPush(this.env, other.env);
        this.setBindVar(other._bindVar);
        return this;
      }
      return root.purePrefix(this, other).setOpts(this.opts);
    };

    BlockPure.prototype.append = function(other) {
      return this._append(other);
    };

    BlockPure.prototype.coerceTry = function() {
      var w;
      w = this.opts.coerce;
      if (w !== "all") {
        return this;
      }
      return root.exprEff(kit.coerceThunk(this.block)).morph(this);
    };

    BlockPure.prototype._capture = function() {
      var ov;
      ov = envThread(this.env);
      if (ov.length) {
        assert.ok(!this.ret);
        this.ret = ov.length === 1 ? ov[0] : kit.arr(ov);
      }
      return this;
    };

    return BlockPure;

  })(Builder);

  root.pure = function(block) {
    return new BlockPure(block);
  };

  Empty = (function(superClass) {
    extend(Empty, superClass);

    function Empty() {
      Empty.__super__.constructor.call(this, []);
    }

    Empty.prototype.append = function(other) {
      return other;
    };

    Empty.prototype.prepend = function(other) {
      return other;
    };

    return Empty;

  })(BlockPure);

  root.empty = function() {
    return new Empty();
  };

  Eff = (function(superClass) {
    extend(Eff, superClass);

    function Eff() {
      Eff.__super__.constructor.call(this);
    }

    Eff.prototype.eff = true;

    Eff.prototype.mkMap = function(args, fun) {
      return kit.mbind(args, fun);
    };

    Eff.prototype.append = function(other) {
      var res;
      envBefore(this.env, other.env);
      if (other.prepend != null) {
        res = other.prepend(this);
        if (res != null) {
          return res;
        }
      }
      return this._append(other);
    };

    Eff.prototype._append = function(other) {
      if (!this._assocDone && this.opts.bindAssoc === "left" && other.eff) {
        this._assocDone = true;
        return root.postfixLeft(this, other).setOpts(other.opts);
      }
      return other.bindTo(this);
    };

    Eff.prototype._capture = function() {
      var fn, ov, val;
      ov = envThread(this.env);
      if (ov.length) {
        if (this.getBindVar() != null) {
          fn = "munshiftTo";
          val = kit.arr(ov);
        } else {
          fn = "mconst";
          val = ov.length === 1 ? ov[0] : kit.arr(ov);
        }
        return root.exprEff(kit.call(kit.mem(this.coerceObj().toExpr(), kit.id(fn)), [val])).morph(this).noCapture();
      }
      return this;
    };

    return Eff;

  })(Builder);

  Cont = (function(superClass) {
    extend(Cont, superClass);

    function Cont(inner1, cont1, isFinal) {
      this.inner = inner1;
      this.cont = cont1;
      Cont.__super__.constructor.call(this);
      if (this.isFinal == null) {
        this.isFinal = isFinal;
      }
    }

    Cont.prototype.addThread = function(thread) {
      this.cont = this.cont.addThread(thread);
      return this;
    };

    Cont.prototype.setBindVar = function(bv) {
      this.cont.setBindVar(bv);
      return this;
    };

    Cont.prototype.setBrk = function(bv) {
      this.cont.setBrk(bv);
      return this;
    };

    Cont.prototype.isBrk = function() {
      return this.cont.isBrk();
    };

    Cont.prototype.result = function() {
      return this.inner._append(this.cont).morph(this);
    };

    Cont.prototype.append = function(other) {
      this.cont = this.cont.append(other);
      if (this.isFinal()) {
        return this.result();
      } else {
        return this;
      }
    };

    Cont.prototype.toExprBuilder = function(eff) {
      return this.result().toExprBuilder(eff);
    };

    Cont.prototype.toBlockBuilder = function(eff) {
      return this.result().toBlockBuilder(eff);
    };

    Cont.prototype.capture = function() {
      return this.result();
    };

    return Cont;

  })(Eff);

  root.cont = function(inner, cont, isFinal) {
    return new Cont(inner, cont, isFinal);
  };

  Postfix = (function(superClass) {
    extend(Postfix, superClass);

    function Postfix(inner, cont, left) {
      this.left = left;
      Postfix.__super__.constructor.call(this, inner, cont);
    }

    Postfix.prototype.isFinal = function() {
      return !this.left && this.cont.eff;
    };

    return Postfix;

  })(Cont);

  root.purePostfix = function(inner, cont) {
    return new Postfix(inner, cont);
  };

  root.postfixLeft = function(inner, cont) {
    return new Postfix(inner, cont, true);
  };

  Par = (function(superClass) {
    extend(Par, superClass);

    function Par(args1, cont1) {
      this.args = args1;
      this.cont = cont1;
      Par.__super__.constructor.call(this);
    }

    Par.prototype.setBindVar = function(bv) {
      this.cont.setBindVar(bv);
      return this;
    };

    Par.prototype.addThread = function(thread) {
      if (this.isBrk()) {
        return this;
      }
      this.cont = this.cont.addThread(thread);
      return this;
    };

    Par.prototype.setBrk = function(bv) {
      this.cont.setBrk(bv);
      return this;
    };

    Par.prototype.isBrk = function() {
      return this.cont.isBrk();
    };

    Par.prototype.append = function(other) {
      if (this.cont.eff) {
        return Par.__super__.append.call(this, other);
      }
      this.cont = this.cont.append(other);
      return this;
    };

    Par.prototype.getDepVars = function() {
      return this.vars;
    };

    Par.prototype.toExprBuilder = function() {
      var ref;
      return (ref = this.cont).bindTo.apply(ref, this.args).morph(this).toExprBuilder();
    };

    Par.prototype.capture = function() {
      return this.toExprBuilder();
    };

    return Par;

  })(Eff);

  root.par = function(vars, args, cont) {
    return new Par(vars, args, cont);
  };

  PurePrefix = (function(superClass) {
    extend(PurePrefix, superClass);

    function PurePrefix(prefix1, cont1) {
      this.prefix = prefix1;
      this.cont = cont1;
      PurePrefix.__super__.constructor.call(this);
      assert.ok(this.cont.eff);
      assert.ok(!this.prefix.eff);
      return;
    }

    PurePrefix.prototype.addThread = function(thread) {
      if (this.isBrk()) {
        return this;
      }
      if (this.last != null) {
        this.last = this.last.addThread(thread);
      } else {
        this.cont = this.cont.addThread(thread);
      }
      return this;
    };

    PurePrefix.prototype.setBindVar = function(bv) {
      var ref;
      ((ref = this.last) != null ? ref : this.cont).setBindVar(bv);
      return this;
    };

    PurePrefix.prototype.setBrk = function(bv) {
      var ref;
      ((ref = this.last) != null ? ref : this.cont).setBrk(bv);
      return this;
    };

    PurePrefix.prototype.isBrk = function() {
      var ref;
      return ((ref = this.last) != null ? ref : this.cont).isBrk();
    };

    PurePrefix.prototype.prepend = function(other) {
      if (!other.eff) {
        this.prefix = other.append(this.prefix);
        return this;
      }
      return this.bindTo(other);
    };

    PurePrefix.prototype.append = function(other) {
      if (this.last) {
        this.cont = this.cont.append(this.last);
      }
      this.last = other;
      return this;
    };

    PurePrefix.prototype.toBlockBuilder = function() {
      return this.capture();
    };

    PurePrefix.prototype.capture = function() {
      var bv, cblock, cont, env, i, last, pblock, ref, ref1, threadOut, v, w;
      if (this.last) {
        last = this.last;
      } else {
        last = this.cont;
      }
      threadOut = {};
      ref = this.prefix.env;
      for (i in ref) {
        v = ref[i];
        if (v.mod && !v.fin) {
          threadOut[i] = true;
        }
      }
      last = last.addThread(threadOut);
      cont = last.capture();
      if (this.last) {
        bv = cont._bindVar;
        cont = this.cont.append(cont).capture();
      }
      env = {};
      envMerge(env = {}, this.prefix.env);
      envMerge(env, cont.env);
      pblock = this.prefix.toPrefix();
      cblock = cont.toBlockBuilder();
      ref1 = cblock.env;
      for (i in ref1) {
        v = ref1[i];
        if (!v.thread) {
          continue;
        }
        w = env[i] != null ? env[i] : env[i] = {
          fin: true
        };
        w.thread = true;
      }
      return root.blockEff(pblock.block.concat(cblock.block)).morph(this, env).needCoerce(cblock._needCoerce).setBindVar(cont.getBindVar()).noCapture().setBrk(this.isBrk());
    };

    return PurePrefix;

  })(Eff);

  root.purePrefix = function(prefix, cont) {
    return new PurePrefix(prefix, cont);
  };

  BlockEff = (function(superClass) {
    extend(BlockEff, superClass);

    function BlockEff(block1) {
      this.block = block1;
      BlockEff.__super__.constructor.call(this);
    }

    BlockEff.prototype.toBlockBuilder = function() {
      return this;
    };

    return BlockEff;

  })(Eff);

  root.blockEff = function(block) {
    return new BlockEff(block);
  };

  root.block = function(eff, block) {
    if (eff) {
      return root.blockEff(block);
    } else {
      return root.pure(block);
    }
  };

  ExprEff = (function(superClass) {
    extend(ExprEff, superClass);

    function ExprEff(expr1) {
      this.expr = expr1;
      ExprEff.__super__.constructor.call(this);
    }

    ExprEff.prototype._coerceObj = function() {
      var w;
      w = this.opts.coerce;
      if (w === "none") {
        return this;
      }
      return root.exprEff(kit.coerceVal(this.expr)).morph(this);
    };

    ExprEff.prototype.toExprBuilder = function() {
      return this;
    };

    return ExprEff;

  })(Eff);

  root.exprEffCoerce = function(expr) {
    return (new ExprEff(expr)).needCoerce();
  };

  root.exprEff = function(expr) {
    return (new ExprEff(expr)).needCoerce(false);
  };

  root.exprEffCaptured = function(expr) {
    return (new ExprEff(expr)).noCapture();
  };

  ExprPure = (function(superClass) {
    extend(ExprPure, superClass);

    function ExprPure(expr1) {
      this.expr = expr1;
      ExprPure.__super__.constructor.call(this, [kit.ret(this.expr)]);
    }

    ExprPure.prototype.toExprBuilder = function(eff) {
      var expr;
      if (!this.expr) {
        return ExprPure.__super__.toExprBuilder.call(this, eff);
      }
      if (!eff) {
        return this;
      }
      expr = this.opts.coerce === "none" ? kit.pure(this.expr) : this.expr;
      return root.exprEff(expr).morph(this);
    };

    ExprPure.prototype.toBlockBuilder = function(eff) {
      var res;
      res = root.pure([]);
      res.ret = this.expr;
      return res.morph(this).toBlockBuilder(eff);
    };

    ExprPure.prototype.toPrefix = function() {
      return root.pure([this._bindVar != null ? kit.varDecl(this._bindVar, this.expr) : kit.exprStmt(this.expr)]).morph(this).setBindVar(false);
    };

    ExprPure.prototype._capture = function() {
      var ov;
      if (!this.expr) {
        return ExprPure.__super__._capture.call(this);
      }
      ov = envThread(this.env);
      if (ov.length) {
        this.expr = kit.arr([this.expr].concat(slice.call(ov)));
        this.block = [kit.ret(this.expr)];
      }
      return this;
    };

    return ExprPure;

  })(BlockPure);

  root.exprPure = function(expr) {
    return new ExprPure(expr);
  };

  root.expr = function(expr, eff) {
    if (eff) {
      return root.exprEffCoerce(expr);
    } else {
      return root.exprPure(expr);
    }
  };

}).call(this);