You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
		
			
		
			
				
					178 lines
				
				4.8 KiB
			
		
		
			
		
	
	
					178 lines
				
				4.8 KiB
			| 
								 
											3 years ago
										 
									 | 
							
								// Generated by LiveScript 1.4.0
							 | 
						||
| 
								 | 
							
								var Func, List, Obj, Str, Num, id, isType, replicate, prelude, toString$ = {}.toString;
							 | 
						||
| 
								 | 
							
								Func = require('./Func.js');
							 | 
						||
| 
								 | 
							
								List = require('./List.js');
							 | 
						||
| 
								 | 
							
								Obj = require('./Obj.js');
							 | 
						||
| 
								 | 
							
								Str = require('./Str.js');
							 | 
						||
| 
								 | 
							
								Num = require('./Num.js');
							 | 
						||
| 
								 | 
							
								id = function(x){
							 | 
						||
| 
								 | 
							
								  return x;
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								isType = curry$(function(type, x){
							 | 
						||
| 
								 | 
							
								  return toString$.call(x).slice(8, -1) === type;
							 | 
						||
| 
								 | 
							
								});
							 | 
						||
| 
								 | 
							
								replicate = curry$(function(n, x){
							 | 
						||
| 
								 | 
							
								  var i$, results$ = [];
							 | 
						||
| 
								 | 
							
								  for (i$ = 0; i$ < n; ++i$) {
							 | 
						||
| 
								 | 
							
								    results$.push(x);
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								  return results$;
							 | 
						||
| 
								 | 
							
								});
							 | 
						||
| 
								 | 
							
								Str.empty = List.empty;
							 | 
						||
| 
								 | 
							
								Str.slice = List.slice;
							 | 
						||
| 
								 | 
							
								Str.take = List.take;
							 | 
						||
| 
								 | 
							
								Str.drop = List.drop;
							 | 
						||
| 
								 | 
							
								Str.splitAt = List.splitAt;
							 | 
						||
| 
								 | 
							
								Str.takeWhile = List.takeWhile;
							 | 
						||
| 
								 | 
							
								Str.dropWhile = List.dropWhile;
							 | 
						||
| 
								 | 
							
								Str.span = List.span;
							 | 
						||
| 
								 | 
							
								Str.breakStr = List.breakList;
							 | 
						||
| 
								 | 
							
								prelude = {
							 | 
						||
| 
								 | 
							
								  Func: Func,
							 | 
						||
| 
								 | 
							
								  List: List,
							 | 
						||
| 
								 | 
							
								  Obj: Obj,
							 | 
						||
| 
								 | 
							
								  Str: Str,
							 | 
						||
| 
								 | 
							
								  Num: Num,
							 | 
						||
| 
								 | 
							
								  id: id,
							 | 
						||
| 
								 | 
							
								  isType: isType,
							 | 
						||
| 
								 | 
							
								  replicate: replicate
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								prelude.each = List.each;
							 | 
						||
| 
								 | 
							
								prelude.map = List.map;
							 | 
						||
| 
								 | 
							
								prelude.filter = List.filter;
							 | 
						||
| 
								 | 
							
								prelude.compact = List.compact;
							 | 
						||
| 
								 | 
							
								prelude.reject = List.reject;
							 | 
						||
| 
								 | 
							
								prelude.partition = List.partition;
							 | 
						||
| 
								 | 
							
								prelude.find = List.find;
							 | 
						||
| 
								 | 
							
								prelude.head = List.head;
							 | 
						||
| 
								 | 
							
								prelude.first = List.first;
							 | 
						||
| 
								 | 
							
								prelude.tail = List.tail;
							 | 
						||
| 
								 | 
							
								prelude.last = List.last;
							 | 
						||
| 
								 | 
							
								prelude.initial = List.initial;
							 | 
						||
| 
								 | 
							
								prelude.empty = List.empty;
							 | 
						||
| 
								 | 
							
								prelude.reverse = List.reverse;
							 | 
						||
| 
								 | 
							
								prelude.difference = List.difference;
							 | 
						||
| 
								 | 
							
								prelude.intersection = List.intersection;
							 | 
						||
| 
								 | 
							
								prelude.union = List.union;
							 | 
						||
| 
								 | 
							
								prelude.countBy = List.countBy;
							 | 
						||
| 
								 | 
							
								prelude.groupBy = List.groupBy;
							 | 
						||
| 
								 | 
							
								prelude.fold = List.fold;
							 | 
						||
| 
								 | 
							
								prelude.foldl = List.foldl;
							 | 
						||
| 
								 | 
							
								prelude.fold1 = List.fold1;
							 | 
						||
| 
								 | 
							
								prelude.foldl1 = List.foldl1;
							 | 
						||
| 
								 | 
							
								prelude.foldr = List.foldr;
							 | 
						||
| 
								 | 
							
								prelude.foldr1 = List.foldr1;
							 | 
						||
| 
								 | 
							
								prelude.unfoldr = List.unfoldr;
							 | 
						||
| 
								 | 
							
								prelude.andList = List.andList;
							 | 
						||
| 
								 | 
							
								prelude.orList = List.orList;
							 | 
						||
| 
								 | 
							
								prelude.any = List.any;
							 | 
						||
| 
								 | 
							
								prelude.all = List.all;
							 | 
						||
| 
								 | 
							
								prelude.unique = List.unique;
							 | 
						||
| 
								 | 
							
								prelude.uniqueBy = List.uniqueBy;
							 | 
						||
| 
								 | 
							
								prelude.sort = List.sort;
							 | 
						||
| 
								 | 
							
								prelude.sortWith = List.sortWith;
							 | 
						||
| 
								 | 
							
								prelude.sortBy = List.sortBy;
							 | 
						||
| 
								 | 
							
								prelude.sum = List.sum;
							 | 
						||
| 
								 | 
							
								prelude.product = List.product;
							 | 
						||
| 
								 | 
							
								prelude.mean = List.mean;
							 | 
						||
| 
								 | 
							
								prelude.average = List.average;
							 | 
						||
| 
								 | 
							
								prelude.concat = List.concat;
							 | 
						||
| 
								 | 
							
								prelude.concatMap = List.concatMap;
							 | 
						||
| 
								 | 
							
								prelude.flatten = List.flatten;
							 | 
						||
| 
								 | 
							
								prelude.maximum = List.maximum;
							 | 
						||
| 
								 | 
							
								prelude.minimum = List.minimum;
							 | 
						||
| 
								 | 
							
								prelude.maximumBy = List.maximumBy;
							 | 
						||
| 
								 | 
							
								prelude.minimumBy = List.minimumBy;
							 | 
						||
| 
								 | 
							
								prelude.scan = List.scan;
							 | 
						||
| 
								 | 
							
								prelude.scanl = List.scanl;
							 | 
						||
| 
								 | 
							
								prelude.scan1 = List.scan1;
							 | 
						||
| 
								 | 
							
								prelude.scanl1 = List.scanl1;
							 | 
						||
| 
								 | 
							
								prelude.scanr = List.scanr;
							 | 
						||
| 
								 | 
							
								prelude.scanr1 = List.scanr1;
							 | 
						||
| 
								 | 
							
								prelude.slice = List.slice;
							 | 
						||
| 
								 | 
							
								prelude.take = List.take;
							 | 
						||
| 
								 | 
							
								prelude.drop = List.drop;
							 | 
						||
| 
								 | 
							
								prelude.splitAt = List.splitAt;
							 | 
						||
| 
								 | 
							
								prelude.takeWhile = List.takeWhile;
							 | 
						||
| 
								 | 
							
								prelude.dropWhile = List.dropWhile;
							 | 
						||
| 
								 | 
							
								prelude.span = List.span;
							 | 
						||
| 
								 | 
							
								prelude.breakList = List.breakList;
							 | 
						||
| 
								 | 
							
								prelude.zip = List.zip;
							 | 
						||
| 
								 | 
							
								prelude.zipWith = List.zipWith;
							 | 
						||
| 
								 | 
							
								prelude.zipAll = List.zipAll;
							 | 
						||
| 
								 | 
							
								prelude.zipAllWith = List.zipAllWith;
							 | 
						||
| 
								 | 
							
								prelude.at = List.at;
							 | 
						||
| 
								 | 
							
								prelude.elemIndex = List.elemIndex;
							 | 
						||
| 
								 | 
							
								prelude.elemIndices = List.elemIndices;
							 | 
						||
| 
								 | 
							
								prelude.findIndex = List.findIndex;
							 | 
						||
| 
								 | 
							
								prelude.findIndices = List.findIndices;
							 | 
						||
| 
								 | 
							
								prelude.apply = Func.apply;
							 | 
						||
| 
								 | 
							
								prelude.curry = Func.curry;
							 | 
						||
| 
								 | 
							
								prelude.flip = Func.flip;
							 | 
						||
| 
								 | 
							
								prelude.fix = Func.fix;
							 | 
						||
| 
								 | 
							
								prelude.over = Func.over;
							 | 
						||
| 
								 | 
							
								prelude.split = Str.split;
							 | 
						||
| 
								 | 
							
								prelude.join = Str.join;
							 | 
						||
| 
								 | 
							
								prelude.lines = Str.lines;
							 | 
						||
| 
								 | 
							
								prelude.unlines = Str.unlines;
							 | 
						||
| 
								 | 
							
								prelude.words = Str.words;
							 | 
						||
| 
								 | 
							
								prelude.unwords = Str.unwords;
							 | 
						||
| 
								 | 
							
								prelude.chars = Str.chars;
							 | 
						||
| 
								 | 
							
								prelude.unchars = Str.unchars;
							 | 
						||
| 
								 | 
							
								prelude.repeat = Str.repeat;
							 | 
						||
| 
								 | 
							
								prelude.capitalize = Str.capitalize;
							 | 
						||
| 
								 | 
							
								prelude.camelize = Str.camelize;
							 | 
						||
| 
								 | 
							
								prelude.dasherize = Str.dasherize;
							 | 
						||
| 
								 | 
							
								prelude.values = Obj.values;
							 | 
						||
| 
								 | 
							
								prelude.keys = Obj.keys;
							 | 
						||
| 
								 | 
							
								prelude.pairsToObj = Obj.pairsToObj;
							 | 
						||
| 
								 | 
							
								prelude.objToPairs = Obj.objToPairs;
							 | 
						||
| 
								 | 
							
								prelude.listsToObj = Obj.listsToObj;
							 | 
						||
| 
								 | 
							
								prelude.objToLists = Obj.objToLists;
							 | 
						||
| 
								 | 
							
								prelude.max = Num.max;
							 | 
						||
| 
								 | 
							
								prelude.min = Num.min;
							 | 
						||
| 
								 | 
							
								prelude.negate = Num.negate;
							 | 
						||
| 
								 | 
							
								prelude.abs = Num.abs;
							 | 
						||
| 
								 | 
							
								prelude.signum = Num.signum;
							 | 
						||
| 
								 | 
							
								prelude.quot = Num.quot;
							 | 
						||
| 
								 | 
							
								prelude.rem = Num.rem;
							 | 
						||
| 
								 | 
							
								prelude.div = Num.div;
							 | 
						||
| 
								 | 
							
								prelude.mod = Num.mod;
							 | 
						||
| 
								 | 
							
								prelude.recip = Num.recip;
							 | 
						||
| 
								 | 
							
								prelude.pi = Num.pi;
							 | 
						||
| 
								 | 
							
								prelude.tau = Num.tau;
							 | 
						||
| 
								 | 
							
								prelude.exp = Num.exp;
							 | 
						||
| 
								 | 
							
								prelude.sqrt = Num.sqrt;
							 | 
						||
| 
								 | 
							
								prelude.ln = Num.ln;
							 | 
						||
| 
								 | 
							
								prelude.pow = Num.pow;
							 | 
						||
| 
								 | 
							
								prelude.sin = Num.sin;
							 | 
						||
| 
								 | 
							
								prelude.tan = Num.tan;
							 | 
						||
| 
								 | 
							
								prelude.cos = Num.cos;
							 | 
						||
| 
								 | 
							
								prelude.acos = Num.acos;
							 | 
						||
| 
								 | 
							
								prelude.asin = Num.asin;
							 | 
						||
| 
								 | 
							
								prelude.atan = Num.atan;
							 | 
						||
| 
								 | 
							
								prelude.atan2 = Num.atan2;
							 | 
						||
| 
								 | 
							
								prelude.truncate = Num.truncate;
							 | 
						||
| 
								 | 
							
								prelude.round = Num.round;
							 | 
						||
| 
								 | 
							
								prelude.ceiling = Num.ceiling;
							 | 
						||
| 
								 | 
							
								prelude.floor = Num.floor;
							 | 
						||
| 
								 | 
							
								prelude.isItNaN = Num.isItNaN;
							 | 
						||
| 
								 | 
							
								prelude.even = Num.even;
							 | 
						||
| 
								 | 
							
								prelude.odd = Num.odd;
							 | 
						||
| 
								 | 
							
								prelude.gcd = Num.gcd;
							 | 
						||
| 
								 | 
							
								prelude.lcm = Num.lcm;
							 | 
						||
| 
								 | 
							
								prelude.VERSION = '1.1.2';
							 | 
						||
| 
								 | 
							
								module.exports = prelude;
							 | 
						||
| 
								 | 
							
								function curry$(f, bound){
							 | 
						||
| 
								 | 
							
								  var context,
							 | 
						||
| 
								 | 
							
								  _curry = function(args) {
							 | 
						||
| 
								 | 
							
								    return f.length > 1 ? function(){
							 | 
						||
| 
								 | 
							
								      var params = args ? args.concat() : [];
							 | 
						||
| 
								 | 
							
								      context = bound ? context || this : this;
							 | 
						||
| 
								 | 
							
								      return params.push.apply(params, arguments) <
							 | 
						||
| 
								 | 
							
								          f.length && arguments.length ?
							 | 
						||
| 
								 | 
							
								        _curry.call(context, params) : f.apply(context, params);
							 | 
						||
| 
								 | 
							
								    } : f;
							 | 
						||
| 
								 | 
							
								  };
							 | 
						||
| 
								 | 
							
								  return _curry();
							 | 
						||
| 
								 | 
							
								}
							 |