nAry : Number -> (* -> a) -> * -> * -> a
339288
function nAry(num, fn) {
  if(!isNumber(num)) {
    throw new TypeError('nAry: Number required for first argument')
  }

  if(!isFunction(fn)) {
    throw new TypeError('nAry: Function required for second argument')
  }

  return curryN(num, fn)
}
467601
function number(value) {
  var parsedNumber = Number.parseInt(value, 10);

  // couldn't parse it
  if (typeOf(parsedNumber) != 'number') {
    return throwModifierError('number', value, {message: 'Invalid Number'});
  }

  return parsedNumber;
}
722467
function elemObjEq(x, y) {
  return (Number.isNaN(x) && Number.isNaN(y)) || x === y;
}
531071
function parseNumber () {
  if (tokenType === TOKENTYPE.NUMBER) {
    let number = new LosslessNumber(token);
    getToken();
    return number;
  }

  return parseSymbol();
}
236955
function isNumberString(x) {
	return x !== 'Infinity' && x !== 'NaN' && x === String(Math.floor(Number(x)))
}
1130757
function padNumber(number, length)
    {
        var result = number.toString();

        while (result.length < length)
            result = '0' + result;

        return result;
    }
1212137
def is_a_number(s):
    
    if _s.fun.is_iterable(s) and not type(s) == str: return False

    try:
        float(s)
        return 1
    except:
        try: 
            complex(s)
            return 2
        except:            
            try: 
                complex(s.replace('(','').replace(')','').replace('i','j'))
                return 2
            except:            
                return False
997086
function fromNumber(num){
    return Lam(Lam((function go(n){return n===0?Var(0):App(Var(1),go(n-1))})(num)));
  }
1224794
def ensure_number(num, *args, **kwargs):
    
    return num if isinstance(num, Number) else Number(num, *args, **kwargs)
629934
function nth(list, indexNum) {
    if (arguments.length == 1) {
      // Manually currying
      indexNum = list;
      return (list) => nth(list, indexNum);
    }

    if(indexNum >= 0) {
      return list[+indexNum]
    };
    return [...list].reverse()[list.length+indexNum];
  }
457233
def is_number(arg):
    '''
    
    '''
    return (is_number(mag(arg)) if is_quantity(arg)              else
            is_npscalar(arg, 'number') or is_npvalue(arg, 'number'))
1109726
function parseNumber (inp) {
    var res = "";
    if (inp.takeAPeek("-")) res += "-";
  
    var match = parseInteger(inp);
    if (match) res += match;
  
    match = parseFraction(inp);
    if (match) res += match;
  
    if (res && res !== "-") {
      match = parseExponent(inp);
      if (match) res += match;
    }
  
    if (res === "-") syntaxError(inp, "Expected number");
    return res || null;
  }
1139346
def number(description, **kwargs) -> typing.Type:
    
    kwargs['description'] = description
    return type('Number', (Number,), kwargs)
700834
def visit_num(self, node, parent):
        """"""
        return nodes.Const(
            node.n,
            getattr(node, "lineno", None),
            getattr(node, "col_offset", None),
            parent,
        )
756449
function() {
    var t = tokens.shift()
    var exp

    if (RE_NUMBER.test(t)) {
      exp = {type: 'n', val: t}
    } else {
      exp = parseExpression()
      tokens.shift()
    }
    return exp
  }
1351326
function nary(binary, args) {
		var len = args.length;
		var result = args[0];
		for (var i = 1; i < len; ++i)
			result = binary(result, args[i]);
		return result;
	}
1024103
def isnumber(*args):
    
    return all(map(lambda c: isinstance(c, int) or isinstance(c, float), args))