From 950ea513c799b577d3a50f977c3227d3872dbc71 Mon Sep 17 00:00:00 2001
From: "Elf M. Sternberg" <elf.sternberg@gmail.com>
Date: Fri, 29 Apr 2016 07:17:52 -0700
Subject: [PATCH] Created a secretive inheritance method for the compiler.  You
 don't need to see this, move along...

---
 bin/activate     |  11 ++++
 src/lists.coffee | 146 +++++++++++++++++++++++++----------------------
 2 files changed, 90 insertions(+), 67 deletions(-)

diff --git a/bin/activate b/bin/activate
index d074497..0693011 100644
--- a/bin/activate
+++ b/bin/activate
@@ -6,3 +6,14 @@
 PROJECT_ROOT=`pwd`
 PATH="$PROJECT_ROOT/bin:$PROJECT_ROOT/node_modules/.bin:$PATH"
 export PATH
+
+if [ -z "$VIRTUAL_ENV_DISABLE_PROMPT" ] ; then
+    _OLD_VIRTUAL_PS1="$PS1"
+    if [ "x" != x ] ; then
+        PS1="$PS1"
+    else
+        PS1="(`basename \"$PROJECT_ROOT\"`)$PS1"
+    fi
+    export PS1
+fi
+
diff --git a/src/lists.coffee b/src/lists.coffee
index 7eec050..81ade57 100644
--- a/src/lists.coffee
+++ b/src/lists.coffee
@@ -34,73 +34,85 @@ ConsList = ->
     writeable: false
   list
 
-nil = (-> new ConsList())()
+_annotate = (ConsList) ->
+  nilp = (c) -> !!c.isList and c.length == 0
+  
+  cons = (a = nil, b = nil) ->
+    return (new ConsList()) if (nilp a) and (nilp b)
+    if (a) then (new ConsList(a, b)) else (new ConsList(b))
+  
+  nil = (-> new ConsList())()
+  
+  vectorp = (c) -> toString.call(c) == '[object Array]'
+  cellp = (c) -> !!c.isList
+  pairp = (c) -> !!c.isList and (c.length == 2)
+  listp = (c) -> !!c.isList and (c.length == 2) and (cellp cdr c)
+  recordp = (c) -> Object.prototype.toString.call(c) == '[object Object]'
+  
+  car = (c) -> c[0]
+  cdr = (c) -> c[1]
+  
+  vectorToList = (v, p) ->
+    p = if p? then p else 0
+    if p >= v.length then return nil
+    # Annoying, but since lists are represented as nested arrays, they
+    # have to be intercepted first.  The use of duck-typing here is
+    # frustrating.
+    item = if pairp(v[p]) then v[p] else
+      if vectorp(v[p]) then vectorToList(v[p]) else v[p]
+    cons(item, vectorToList(v, p + 1))
+  
+  list = (v...) ->
+    ln = v.length
+    (nl = (a) ->
+      cons(v[a], if (a < ln) then (nl(a + 1)) else nil))(0)
+  
+  listToVector = (l, v = []) ->
+    return v if nilp l
+    v.push if pairp (car l) then listToVector(car l) else (car l)
+    listToVector (cdr l), v
+  
+  metacadr = (m) ->
+    ops = {'a': car, 'd': cdr}
+    seq = vectorToList m.match(/c([ad]+)r/)[1].split('').reverse()
+    return (l) ->
+      inner = (l, s) ->
+        return l if (nilp l) or (nilp s)
+        inner ops[(car s)](l), (cdr s)
+      inner l, seq
 
-vectorp = (c) -> toString.call(c) == '[object Array]'
-cellp = (c) -> !!c.isList
-pairp = (c) -> !!c.isList and (c.length == 2)
-listp = (c) -> !!c.isList and (c.length == 2) and (cellp cdr c)
-recordp = (c) -> Object.prototype.toString.call(c) == '[object Object]'
-nilp = (c) -> !!c.isList and c.length == 0
+  {
+    cons: cons
+    nil: nil
+    car: car
+    cdr: cdr
+    list: list
+    nilp: nilp
+    cellp: cellp
+    pairp: pairp
+    listp: listp
+    vectorToList: vectorToList
+    listToVector: listToVector
+    setcar: (a, l) -> l[0] = a; a
+    setcdr: (a, l) -> l[1] = a; a
+    cadr: (l) -> car (cdr l)
+    cddr: (l) -> cdr (cdr l)
+    cdar: (l) -> cdr (car l)
+    caar: (l) -> car (car l)
+    caddr: (l) -> car (cdr (cdr l))
+    cdddr: (l) -> cdr (cdr (cdr l))
+    cadar: (l) -> car (cdr (car l))
+    cddar: (l) -> cdr (cdr (car l))
+    caadr: (l) -> car (car (cdr l))
+    cdadr: (l) -> cdr (car (cdr l))
+    metacadr: metacadr
+  }
 
-cons = (a = nil, b = nil) ->
-  return (new ConsList()) if (nilp a) and (nilp b)
-  if (a) then (new ConsList(a, b)) else (new ConsList(b))
+_export = _annotate(ConsList)
+Object.defineProperty _export, '_annotate',
+    value: _annotate
+    configurable: false,
+    enumerable: false,
+    writeable: false
 
-car = (c) -> c[0]
-cdr = (c) -> c[1]
-
-vectorToList = (v, p) ->
-  p = if p? then p else 0
-  if p >= v.length then return nil
-  # Annoying, but since lists are represented as nested arrays, they
-  # have to be intercepted first.  The use of duck-typing here is
-  # frustrating.
-  item = if pairp(v[p]) then v[p] else
-    if vectorp(v[p]) then vectorToList(v[p]) else v[p]
-  cons(item, vectorToList(v, p + 1))
-
-list = (v...) ->
-  ln = v.length
-  (nl = (a) ->
-    cons(v[a], if (a < ln) then (nl(a + 1)) else nil))(0)
-
-listToVector = (l, v = []) ->
-  return v if nilp l
-  v.push if pairp (car l) then listToVector(car l) else (car l)
-  listToVector (cdr l), v
-
-metacadr = (m) ->
-  ops = {'a': car, 'd': cdr}
-  seq = vectorToList m.match(/c([ad]+)r/)[1].split('').reverse()
-  return (l) ->
-    inner = (l, s) ->
-      return l if (nilp l) or (nilp s)
-      inner ops[(car s)](l), (cdr s)
-    inner l, seq
-
-module.exports =
-  cons: cons
-  nil: nil
-  car: car
-  cdr: cdr
-  list: list
-  nilp: nilp
-  cellp: cellp
-  pairp: pairp
-  listp: listp
-  vectorToList: vectorToList
-  listToVector: listToVector
-  setcar: (a, l) -> l[0] = a; a
-  setcdr: (a, l) -> l[1] = a; a
-  cadr: (l) -> car (cdr l)
-  cddr: (l) -> cdr (cdr l)
-  cdar: (l) -> cdr (car l)
-  caar: (l) -> car (car l)
-  caddr: (l) -> car (cdr (cdr l))
-  cdddr: (l) -> cdr (cdr (cdr l))
-  cadar: (l) -> car (cdr (car l))
-  cddar: (l) -> cdr (cdr (car l))
-  caadr: (l) -> car (car (cdr l))
-  cdadr: (l) -> cdr (car (cdr l))
-  metacadr: metacadr
+module.exports = _export