js/types.js

   1 // Node vs browser behavior
   2 var types = {};
   3 if (typeof module === 'undefined') {
   4     var exports = types;
   5 }
   6
   7 // General functions
   8
   9 function _obj_type(obj) {
  10     if      (_symbol_Q(obj)) {   return 'symbol'; }
  11     else if (_list_Q(obj)) {     return 'list'; }
  12     else if (_vector_Q(obj)) {   return 'vector'; }
  13     else if (_hash_map_Q(obj)) { return 'hash-map'; }
  14     else if (_nil_Q(obj)) {      return 'nil'; }
  15     else if (_true_Q(obj)) {     return 'true'; }
  16     else if (_false_Q(obj)) {    return 'false'; }
  17     else if (_atom_Q(obj)) {     return 'atom'; }
  18     else {
  19         switch (typeof(obj)) {
  20         case 'number':   return 'number';
  21         case 'function': return 'function';
  22         case 'string': return obj[0] == '\u029e' ? 'keyword' : 'string';
  23         default: throw new Error("Unknown type '" + typeof(obj) + "'");
  24         }
  25     }
  26 }
  27
  28 function _sequential_Q(lst) { return _list_Q(lst) || _vector_Q(lst); }
  29
  30
  31 function _equal_Q (a, b) {
  32     var ota = _obj_type(a), otb = _obj_type(b);
  33     if (!(ota === otb || (_sequential_Q(a) && _sequential_Q(b)))) {
  34         return false;
  35     }
  36     switch (ota) {
  37     case 'symbol': return a.value === b.value;
  38     case 'list':
  39     case 'vector':
  40         if (a.length !== b.length) { return false; }
  41         for (var i=0; i<a.length; i++) {
  42             if (! _equal_Q(a[i], b[i])) { return false; }
  43         }
  44         return true;
  45     case 'hash-map':
  46         if (Object.keys(a).length !== Object.keys(b).length) { return false; }
  47         for (var k in a) {
  48             if (! _equal_Q(a[k], b[k])) { return false; }
  49         }
  50         return true;
  51     default:
  52         return a === b;
  53     }
  54 }
  55
  56
  57 function _clone (obj) {
  58     var new_obj;
  59     switch (_obj_type(obj)) {
  60     case 'list':
  61         new_obj = obj.slice(0);
  62         break;
  63     case 'vector':
  64         new_obj = obj.slice(0);
  65         new_obj.__isvector__ = true;
  66         break;
  67     case 'hash-map':
  68         new_obj = {};
  69         for (var k in obj) {
  70             if (obj.hasOwnProperty(k)) { new_obj[k] = obj[k]; }
  71         }
  72         break;
  73     case 'function':
  74         new_obj = obj.clone();
  75         break;
  76     default:
  77         throw new Error("clone of non-collection: " + _obj_type(obj));
  78     }
  79     Object.defineProperty(new_obj, "__meta__", {
  80         enumerable: false,
  81         writable: true
  82     });
  83     return new_obj;
  84 }
  85
  86
  87 // Scalars
  88 function _nil_Q(a) { return a === null ? true : false; }
  89 function _true_Q(a) { return a === true ? true : false; }
  90 function _false_Q(a) { return a === false ? true : false; }
  91
  92
  93 // Symbols
  94 function Symbol(name) {
  95     this.value = name;
  96     return this;
  97 }
  98 Symbol.prototype.toString = function() { return this.value; }
  99 function _symbol(name) { return new Symbol(name); }
 100 function _symbol_Q(obj) { return obj instanceof Symbol; }
 101
 102
 103 // Keywords
 104 function _keyword(obj) {
 105     if (typeof obj === 'string' && obj[0] === '\u029e') {
 106         return obj;
 107     } else {
 108         return "\u029e" + obj;
 109     }
 110 }
 111 function _keyword_Q(obj) {
 112     return typeof obj === 'string' && obj[0] === '\u029e';
 113 }
 114
 115
 116 // Functions
 117 function _function(Eval, Env, ast, env, params) {
 118     var fn = function() {
 119         return Eval(ast, new Env(env, params, arguments));
 120     };
 121     fn.__meta__ = null;
 122     fn.__ast__ = ast;
 123     fn.__gen_env__ = function(args) { return new Env(env, params, args); };
 124     fn._ismacro_ = false;
 125     return fn;
 126 }
 127 function _function_Q(obj) { return typeof obj == "function"; }
 128 Function.prototype.clone = function() {
 129     var that = this;
 130     var temp = function () { return that.apply(this, arguments); };
 131     for( key in this ) {
 132         temp[key] = this[key];
 133     }
 134     return temp;
 135 };
 136
 137
 138 // Lists
 139 function _list() { return Array.prototype.slice.call(arguments, 0); }
 140 function _list_Q(obj) { return Array.isArray(obj) && !obj.__isvector__; }
 141
 142
 143 // Vectors
 144 function _vector() {
 145     var v = Array.prototype.slice.call(arguments, 0);
 146     v.__isvector__ = true;
 147     return v;
 148 }
 149 function _vector_Q(obj) { return Array.isArray(obj) && !!obj.__isvector__; }
 150
 151
 152
 153 // Hash Maps
 154 function _hash_map() {
 155     if (arguments.length % 2 === 1) {
 156         throw new Error("Odd number of hash map arguments");
 157     }
 158     var args = [{}].concat(Array.prototype.slice.call(arguments, 0));
 159     return _assoc_BANG.apply(null, args);
 160 }
 161 function _hash_map_Q(hm) {
 162     return typeof hm === "object" &&
 163            !Array.isArray(hm) &&
 164            !(hm === null) &&
 165            !(hm instanceof Symbol) &&
 166            !(hm instanceof Atom);
 167 }
 168 function _assoc_BANG(hm) {
 169     if (arguments.length % 2 !== 1) {
 170         throw new Error("Odd number of assoc arguments");
 171     }
 172     for (var i=1; i<arguments.length; i+=2) {
 173         var ktoken = arguments[i],
 174             vtoken = arguments[i+1];
 175         if (typeof ktoken !== "string") {
 176             throw new Error("expected hash-map key string, got: " + (typeof ktoken));
 177         }
 178         hm[ktoken] = vtoken;
 179     }
 180     return hm;
 181 }
 182 function _dissoc_BANG(hm) {
 183     for (var i=1; i<arguments.length; i++) {
 184         var ktoken = arguments[i];
 185         delete hm[ktoken];
 186     }
 187     return hm;
 188 }
 189
 190
 191 // Atoms
 192 function Atom(val) { this.val = val; }
 193 function _atom(val) { return new Atom(val); }
 194 function _atom_Q(atm) { return atm instanceof Atom; }
 195
 196
 197 // Exports
 198 exports._obj_type = types._obj_type = _obj_type;
 199 exports._sequential_Q = types._sequential_Q = _sequential_Q;
 200 exports._equal_Q = types._equal_Q = _equal_Q;
 201 exports._clone = types._clone = _clone;
 202 exports._nil_Q = types._nil_Q = _nil_Q;
 203 exports._true_Q = types._true_Q = _true_Q;
 204 exports._false_Q = types._false_Q = _false_Q;
 205 exports._symbol = types._symbol = _symbol;
 206 exports._symbol_Q = types._symbol_Q = _symbol_Q;
 207 exports._keyword = types._keyword = _keyword;
 208 exports._keyword_Q = types._keyword_Q = _keyword_Q;
 209 exports._function = types._function = _function;
 210 exports._function_Q = types._function_Q = _function_Q;
 211 exports._list = types._list = _list;
 212 exports._list_Q = types._list_Q = _list_Q;
 213 exports._vector = types._vector = _vector;
 214 exports._vector_Q = types._vector_Q = _vector_Q;
 215 exports._hash_map = types._hash_map = _hash_map;
 216 exports._hash_map_Q = types._hash_map_Q = _hash_map_Q;
 217 exports._assoc_BANG = types._assoc_BANG = _assoc_BANG;
 218 exports._dissoc_BANG = types._dissoc_BANG = _dissoc_BANG;
 219 exports._atom = types._atom = _atom;
 220 exports._atom_Q = types._atom_Q = _atom_Q;