A collection of Lodash method updates.

LodashPlus.coffee

_.isVoid = (variable) ->

    return _.isUndefined(variable) or _.isNull(variable)

_.isTruthy = (variable) ->

    return Boolean(variable) is true

_.isFalsey = (variable) ->

    return Boolean(variable) is false

_.isZero = (variable) ->

    return variable is 0

_.isPositive = (variable) ->

    return _.isNumber(variable) and variable > 0

_.isNegative = (variable) ->

    return _.isNumber(variable) and variable < 0

_.isInteger = (variable) ->

    return _.isNumber(variable) and variable % 1 is 0

_.isFloat = (variable) ->

    return _.isNumber(variable) and variable % 1 isnt 0

_.isObject = (variable) ->

    return typeof variable is "object" and variable isnt null and not _.isArray variable

_.isBlueprint = (variable) ->

    if typeof variable is "function" and variable.prototype isnt undefined

        try

            variable()

        catch error

            return true

        return false

    return false

_.isClass = (variable) ->

    try

        return typeof variable is "object" and variable.constructor.name isnt "Object" and variable.constructor.name isnt "Array"

    catch error

        return false

LodashPlus.js

const _ = require("lodash")

_.isVoid = function(variable) {
  return _.isUndefined(variable) || _.isNull(variable);
};

_.isTruthy = function(variable) {
  return Boolean(variable) === true;
};

_.isFalsey = function(variable) {
  return Boolean(variable) === false;
};

_.isZero = function(variable) {
  return variable === 0;
};

_.isPositive = function(variable) {
  return _.isNumber(variable) && variable > 0;
};

_.isNegative = function(variable) {
  return _.isNumber(variable) && variable < 0;
};

_.isInteger = function(variable) {
  return _.isNumber(variable) && variable % 1 === 0;
};

_.isFloat = function(variable) {
  return _.isNumber(variable) && variable % 1 !== 0;
};

_.isObject = function(variable) {
  return typeof variable === "object" && variable !== null && !_.isArray(variable);
};

_.isBlueprint = function(variable) {
  var error;
  if (typeof variable === "function" && variable.prototype !== void 0) {
    try {
      variable();
    } catch (error1) {
      error = error1;
      return true;
    }
    return false;
  }
  return false;
};

_.isClass = function(variable) {
  var error;
  try {
    return typeof variable === "object" && variable.constructor.name !== "Object" && variable.constructor.name !== "Array";
  } catch (error1) {
    error = error1;
    return false;
  }
};

LodashPlusDocs.md

Lodash Plus Docs

isVoid

This method is not part of the core Lodash library but I have added it for convenience. It will return true for undefined and null.

isUndefined

This method is part of the core Lodash library and I have not modified it in any way.

isNull

This method is part of the core Lodash library and I have not modified it in any way.

isBoolean

This method is part of the core Lodash library and I have not modified it in any way.

isTruthy

This method is not part of the core Lodash library but I have added it for convenience. It will cast to a boolean and return true if the result is true.

isFalsey

This method is not part of the core Lodash library but I have added it for convenience. It will cast to a boolean and return true if the result is false.

isNumber

This method is part of the core Lodash library and I have not modified it in any way.

isZero

This method is not part of the core Lodash library but I have added it for convenience. It will return true for 0 only.

isPositive

This method is not part of the core Lodash library but I have added it for convenience. It will return true for numbers greater than 0.

isNegative

This method is not part of the core Lodash library but I have added it for convenience. It will return true for numbers less than 0.

isInteger

This method is not part of the core Lodash library but I have added it for convenience. It will return true for numbers that are integers.

isFloat

This method is not part of the core Lodash library but I have added it for convenience. It will return true for numbers that are floats.

isString

This method is part of the core Lodash library and I have not modified it in any way.

isArray

This method is part of the core Lodash library and I have not modified it in any way.

isObject

This method is part of the core Lodash library but I have modified it to make more sense to me. The primary issue was that the core version would return true for functions and arrays in addition to literal objects. Now it will only return true for literal objects and classes.

isFunction

This method is part of the core Lodash library and I have not modified it in any way.

isBlueprint

This method is not part of the core Lodash library but I have added it for convenience. It will return true for any class definition.

isClass

This method is not part of the core Lodash library but I have added it for convenience. It will return true for any instance of a class.

LodashPlusTests.coffee

### Lodash Testing ###

## Data ##

# Void #

_undefined = undefined
_null = null

# Booleans #

_true = true
_false = false

# Numbers #

zero = 0
positiveInteger = 1
negativeInteger = -1
positiveFloat = 0.5
negativeFloat = -0.5

# Strings #

string = "abc"
emptyString = ""

# Arrays #

array = [1, 2, 3]
emptyArray = []

# Objects #

object = {test: "Test"}
emptyObject = {}

# Functions #

funcWithArgs = (arg) -> null
funcNoArgs = -> null

# Blueprints #

class Blueprint

    constructor: ->

        return this

# Classes #

blueprint = new Blueprint()

## isVoid Tests ##

console.assert _.isVoid(_undefined) is true
console.assert _.isVoid(_null) is true
console.assert _.isVoid(_true) is false
console.assert _.isVoid(_false) is false
console.assert _.isVoid(zero) is false
console.assert _.isVoid(positiveInteger) is false
console.assert _.isVoid(negativeInteger) is false
console.assert _.isVoid(positiveFloat) is false
console.assert _.isVoid(negativeFloat) is false
console.assert _.isVoid(string) is false
console.assert _.isVoid(emptyString) is false
console.assert _.isVoid(array) is false
console.assert _.isVoid(emptyArray) is false
console.assert _.isVoid(object) is false
console.assert _.isVoid(emptyObject) is false
console.assert _.isVoid(funcWithArgs) is false
console.assert _.isVoid(funcNoArgs) is false
console.assert _.isVoid(Blueprint) is false
console.assert _.isVoid(blueprint) is false

## isUndefined Tests ##

console.assert _.isUndefined(_undefined) is true
console.assert _.isUndefined(_null) is false
console.assert _.isUndefined(_true) is false
console.assert _.isUndefined(_false) is false
console.assert _.isUndefined(zero) is false
console.assert _.isUndefined(positiveInteger) is false
console.assert _.isUndefined(negativeInteger) is false
console.assert _.isUndefined(positiveFloat) is false
console.assert _.isUndefined(negativeFloat) is false
console.assert _.isUndefined(string) is false
console.assert _.isUndefined(emptyString) is false
console.assert _.isUndefined(array) is false
console.assert _.isUndefined(emptyArray) is false
console.assert _.isUndefined(object) is false
console.assert _.isUndefined(emptyObject) is false
console.assert _.isUndefined(funcWithArgs) is false
console.assert _.isUndefined(funcNoArgs) is false
console.assert _.isUndefined(Blueprint) is false
console.assert _.isUndefined(blueprint) is false

## isNull Tests ##

console.assert _.isNull(_undefined) is false
console.assert _.isNull(_null) is true
console.assert _.isNull(_true) is false
console.assert _.isNull(_false) is false
console.assert _.isNull(zero) is false
console.assert _.isNull(positiveInteger) is false
console.assert _.isNull(negativeInteger) is false
console.assert _.isNull(positiveFloat) is false
console.assert _.isNull(negativeFloat) is false
console.assert _.isNull(string) is false
console.assert _.isNull(emptyString) is false
console.assert _.isNull(array) is false
console.assert _.isNull(emptyArray) is false
console.assert _.isNull(object) is false
console.assert _.isNull(emptyObject) is false
console.assert _.isNull(funcWithArgs) is false
console.assert _.isNull(funcNoArgs) is false
console.assert _.isNull(Blueprint) is false
console.assert _.isNull(blueprint) is false

## isBoolean Tests ##

console.assert _.isBoolean(_undefined) is false
console.assert _.isBoolean(_null) is false
console.assert _.isBoolean(_true) is true
console.assert _.isBoolean(_false) is true
console.assert _.isBoolean(zero) is false
console.assert _.isBoolean(positiveInteger) is false
console.assert _.isBoolean(negativeInteger) is false
console.assert _.isBoolean(positiveFloat) is false
console.assert _.isBoolean(negativeFloat) is false
console.assert _.isBoolean(string) is false
console.assert _.isBoolean(emptyString) is false
console.assert _.isBoolean(array) is false
console.assert _.isBoolean(emptyArray) is false
console.assert _.isBoolean(object) is false
console.assert _.isBoolean(emptyObject) is false
console.assert _.isBoolean(funcWithArgs) is false
console.assert _.isBoolean(funcNoArgs) is false
console.assert _.isBoolean(Blueprint) is false
console.assert _.isBoolean(blueprint) is false

## isTruthy Tests ##

console.assert _.isTruthy(_undefined) is false
console.assert _.isTruthy(_null) is false
console.assert _.isTruthy(_true) is true
console.assert _.isTruthy(_false) is false
console.assert _.isTruthy(zero) is false
console.assert _.isTruthy(positiveInteger) is true
console.assert _.isTruthy(negativeInteger) is true # slightly counterintuitive
console.assert _.isTruthy(positiveFloat) is true
console.assert _.isTruthy(negativeFloat) is true # slightly counterintuitive
console.assert _.isTruthy(string) is true
console.assert _.isTruthy(emptyString) is false
console.assert _.isTruthy(array) is true
console.assert _.isTruthy(emptyArray) is true # counterintuitive
console.assert _.isTruthy(object) is true
console.assert _.isTruthy(emptyObject) is true # counterintuitive
console.assert _.isTruthy(funcWithArgs) is true
console.assert _.isTruthy(funcNoArgs) is true
console.assert _.isTruthy(Blueprint) is true
console.assert _.isTruthy(blueprint) is true

## isFalsey Tests ##

console.assert _.isFalsey(_undefined) is true
console.assert _.isFalsey(_null) is true
console.assert _.isFalsey(_true) is false
console.assert _.isFalsey(_false) is true
console.assert _.isFalsey(zero) is true
console.assert _.isFalsey(positiveInteger) is false
console.assert _.isFalsey(negativeInteger) is false # slightly counterintuitive
console.assert _.isFalsey(positiveFloat) is false
console.assert _.isFalsey(negativeFloat) is false # slightly counterintuitive
console.assert _.isFalsey(string) is false
console.assert _.isFalsey(emptyString) is true
console.assert _.isFalsey(array) is false
console.assert _.isFalsey(emptyArray) is false # counterintuitive
console.assert _.isFalsey(object) is false
console.assert _.isFalsey(emptyObject) is false # counterintuitive
console.assert _.isFalsey(funcWithArgs) is false
console.assert _.isFalsey(funcNoArgs) is false
console.assert _.isFalsey(Blueprint) is false
console.assert _.isFalsey(blueprint) is false

## isNumber Tests ##

console.assert _.isNumber(_undefined) is false
console.assert _.isNumber(_null) is false
console.assert _.isNumber(_true) is false
console.assert _.isNumber(_false) is false
console.assert _.isNumber(zero) is true
console.assert _.isNumber(positiveInteger) is true
console.assert _.isNumber(negativeInteger) is true
console.assert _.isNumber(positiveFloat) is true
console.assert _.isNumber(negativeFloat) is true
console.assert _.isNumber(string) is false
console.assert _.isNumber(emptyString) is false
console.assert _.isNumber(array) is false
console.assert _.isNumber(emptyArray) is false
console.assert _.isNumber(object) is false
console.assert _.isNumber(emptyObject) is false
console.assert _.isNumber(funcWithArgs) is false
console.assert _.isNumber(funcNoArgs) is false
console.assert _.isNumber(Blueprint) is false
console.assert _.isNumber(blueprint) is false

## isZero Tests ##

console.assert _.isZero(_undefined) is false
console.assert _.isZero(_null) is false
console.assert _.isZero(_true) is false
console.assert _.isZero(_false) is false
console.assert _.isZero(zero) is true
console.assert _.isZero(positiveInteger) is false
console.assert _.isZero(negativeInteger) is false
console.assert _.isZero(positiveFloat) is false
console.assert _.isZero(negativeFloat) is false
console.assert _.isZero(string) is false
console.assert _.isZero(emptyString) is false
console.assert _.isZero(array) is false
console.assert _.isZero(emptyArray) is false
console.assert _.isZero(object) is false
console.assert _.isZero(emptyObject) is false
console.assert _.isZero(funcWithArgs) is false
console.assert _.isZero(funcNoArgs) is false
console.assert _.isZero(Blueprint) is false
console.assert _.isZero(blueprint) is false

## isPositive Tests ##

console.assert _.isPositive(_undefined) is false
console.assert _.isPositive(_null) is false
console.assert _.isPositive(_true) is false
console.assert _.isPositive(_false) is false
console.assert _.isPositive(zero) is false
console.assert _.isPositive(positiveInteger) is true
console.assert _.isPositive(negativeInteger) is false
console.assert _.isPositive(positiveFloat) is true
console.assert _.isPositive(negativeFloat) is false
console.assert _.isPositive(string) is false
console.assert _.isPositive(emptyString) is false
console.assert _.isPositive(array) is false
console.assert _.isPositive(emptyArray) is false
console.assert _.isPositive(object) is false
console.assert _.isPositive(emptyObject) is false
console.assert _.isPositive(funcWithArgs) is false
console.assert _.isPositive(funcNoArgs) is false
console.assert _.isPositive(Blueprint) is false
console.assert _.isPositive(blueprint) is false

## isNegative Tests ##

console.assert _.isNegative(_undefined) is false
console.assert _.isNegative(_null) is false
console.assert _.isNegative(_true) is false
console.assert _.isNegative(_false) is false
console.assert _.isNegative(zero) is false
console.assert _.isNegative(positiveInteger) is false
console.assert _.isNegative(negativeInteger) is true
console.assert _.isNegative(positiveFloat) is false
console.assert _.isNegative(negativeFloat) is true
console.assert _.isNegative(string) is false
console.assert _.isNegative(emptyString) is false
console.assert _.isNegative(array) is false
console.assert _.isNegative(emptyArray) is false
console.assert _.isNegative(object) is false
console.assert _.isNegative(emptyObject) is false
console.assert _.isNegative(funcWithArgs) is false
console.assert _.isNegative(funcNoArgs) is false
console.assert _.isNegative(Blueprint) is false
console.assert _.isNegative(blueprint) is false

## isInteger Tests ##

console.assert _.isInteger(_undefined) is false
console.assert _.isInteger(_null) is false
console.assert _.isInteger(_true) is false
console.assert _.isInteger(_false) is false
console.assert _.isInteger(zero) is true
console.assert _.isInteger(positiveInteger) is true
console.assert _.isInteger(negativeInteger) is true
console.assert _.isInteger(positiveFloat) is false
console.assert _.isInteger(negativeFloat) is false
console.assert _.isInteger(string) is false
console.assert _.isInteger(emptyString) is false
console.assert _.isInteger(array) is false
console.assert _.isInteger(emptyArray) is false
console.assert _.isInteger(object) is false
console.assert _.isInteger(emptyObject) is false
console.assert _.isInteger(funcWithArgs) is false
console.assert _.isInteger(funcNoArgs) is false
console.assert _.isInteger(Blueprint) is false
console.assert _.isInteger(blueprint) is false

## isFloat Tests ##

console.assert _.isFloat(_undefined) is false
console.assert _.isFloat(_null) is false
console.assert _.isFloat(_true) is false
console.assert _.isFloat(_false) is false
console.assert _.isFloat(zero) is false
console.assert _.isFloat(positiveInteger) is false
console.assert _.isFloat(negativeInteger) is false
console.assert _.isFloat(positiveFloat) is true
console.assert _.isFloat(negativeFloat) is true
console.assert _.isFloat(string) is false
console.assert _.isFloat(emptyString) is false
console.assert _.isFloat(array) is false
console.assert _.isFloat(emptyArray) is false
console.assert _.isFloat(object) is false
console.assert _.isFloat(emptyObject) is false
console.assert _.isFloat(funcWithArgs) is false
console.assert _.isFloat(funcNoArgs) is false
console.assert _.isFloat(Blueprint) is false
console.assert _.isFloat(blueprint) is false

## isString Tests ##

console.assert _.isString(_undefined) is false
console.assert _.isString(_null) is false
console.assert _.isString(_true) is false
console.assert _.isString(_false) is false
console.assert _.isString(zero) is false
console.assert _.isString(positiveInteger) is false
console.assert _.isString(negativeInteger) is false
console.assert _.isString(positiveFloat) is false
console.assert _.isString(negativeFloat) is false
console.assert _.isString(string) is true
console.assert _.isString(emptyString) is true
console.assert _.isString(array) is false
console.assert _.isString(emptyArray) is false
console.assert _.isString(object) is false
console.assert _.isString(emptyObject) is false
console.assert _.isString(funcWithArgs) is false
console.assert _.isString(funcNoArgs) is false
console.assert _.isString(Blueprint) is false
console.assert _.isString(blueprint) is false

## isArray Tests ##

console.assert _.isArray(_undefined) is false
console.assert _.isArray(_null) is false
console.assert _.isArray(_true) is false
console.assert _.isArray(_false) is false
console.assert _.isArray(zero) is false
console.assert _.isArray(positiveInteger) is false
console.assert _.isArray(negativeInteger) is false
console.assert _.isArray(positiveFloat) is false
console.assert _.isArray(negativeFloat) is false
console.assert _.isArray(string) is false
console.assert _.isArray(emptyString) is false
console.assert _.isArray(array) is true
console.assert _.isArray(emptyArray) is true
console.assert _.isArray(object) is false
console.assert _.isArray(emptyObject) is false
console.assert _.isArray(funcWithArgs) is false
console.assert _.isArray(funcNoArgs) is false
console.assert _.isArray(Blueprint) is false
console.assert _.isArray(blueprint) is false

## isObject Tests ##

console.assert _.isObject(_undefined) is false
console.assert _.isObject(_null) is false
console.assert _.isObject(_true) is false
console.assert _.isObject(_false) is false
console.assert _.isObject(zero) is false
console.assert _.isObject(positiveInteger) is false
console.assert _.isObject(negativeInteger) is false
console.assert _.isObject(positiveFloat) is false
console.assert _.isObject(negativeFloat) is false
console.assert _.isObject(string) is false
console.assert _.isObject(emptyString) is false
console.assert _.isObject(array) is false
console.assert _.isObject(emptyArray) is false
console.assert _.isObject(object) is true
console.assert _.isObject(emptyObject) is true
console.assert _.isObject(funcWithArgs) is false
console.assert _.isObject(funcNoArgs) is false
console.assert _.isObject(Blueprint) is false
console.assert _.isObject(blueprint) is true # slightly counterintuitive

## isFunction Tests ##

console.assert _.isFunction(_undefined) is false
console.assert _.isFunction(_null) is false
console.assert _.isFunction(_true) is false
console.assert _.isFunction(_false) is false
console.assert _.isFunction(zero) is false
console.assert _.isFunction(positiveInteger) is false
console.assert _.isFunction(negativeInteger) is false
console.assert _.isFunction(positiveFloat) is false
console.assert _.isFunction(negativeFloat) is false
console.assert _.isFunction(string) is false
console.assert _.isFunction(emptyString) is false
console.assert _.isFunction(array) is false
console.assert _.isFunction(emptyArray) is false
console.assert _.isFunction(object) is false
console.assert _.isFunction(emptyObject) is false
console.assert _.isFunction(funcWithArgs) is true
console.assert _.isFunction(funcNoArgs) is true
console.assert _.isFunction(Blueprint) is true # counterintuitive
console.assert _.isFunction(blueprint) is false

## isBlueprint Tests ##

console.assert _.isBlueprint(_undefined) is false
console.assert _.isBlueprint(_null) is false
console.assert _.isBlueprint(_true) is false
console.assert _.isBlueprint(_false) is false
console.assert _.isBlueprint(zero) is false
console.assert _.isBlueprint(positiveInteger) is false
console.assert _.isBlueprint(negativeInteger) is false
console.assert _.isBlueprint(positiveFloat) is false
console.assert _.isBlueprint(negativeFloat) is false
console.assert _.isBlueprint(string) is false
console.assert _.isBlueprint(emptyString) is false
console.assert _.isBlueprint(array) is false
console.assert _.isBlueprint(emptyArray) is false
console.assert _.isBlueprint(object) is false
console.assert _.isBlueprint(emptyObject) is false
console.assert _.isBlueprint(funcWithArgs) is false
console.assert _.isBlueprint(funcNoArgs) is false
console.assert _.isBlueprint(Blueprint) is true
console.assert _.isBlueprint(blueprint) is false

## isClass Tests ##

console.assert _.isClass(_undefined) is false
console.assert _.isClass(_null) is false
console.assert _.isClass(_true) is false
console.assert _.isClass(_false) is false
console.assert _.isClass(zero) is false
console.assert _.isClass(positiveInteger) is false
console.assert _.isClass(negativeInteger) is false
console.assert _.isClass(positiveFloat) is false
console.assert _.isClass(negativeFloat) is false
console.assert _.isClass(string) is false
console.assert _.isClass(emptyString) is false
console.assert _.isClass(array) is false
console.assert _.isClass(emptyArray) is false
console.assert _.isClass(object) is false
console.assert _.isClass(emptyObject) is false
console.assert _.isClass(funcWithArgs) is false
console.assert _.isClass(funcNoArgs) is false
console.assert _.isClass(Blueprint) is false
console.assert _.isClass(blueprint) is true

LodashPlusTests.js

/* Lodash Testing */

//# Data ##

// Void #

_undefined = void 0;

_null = null;

// Booleans #

_true = true;

_false = false;

// Numbers #

zero = 0;

positiveInteger = 1;

negativeInteger = -1;

positiveFloat = 0.5;

negativeFloat = -0.5;

// Strings #

string = "abc";

emptyString = "";

// Arrays #

array = [1, 2, 3];

emptyArray = [];

// Objects #

object = {
  test: "Test"
};

emptyObject = {};

// Functions #

funcWithArgs = function(arg) {
  return null;
};

funcNoArgs = function() {
  return null;
};

// Blueprints #

Blueprint = class Blueprint {
  constructor() {
    return this;
  }
};

// Classes #

blueprint = new Blueprint();

//# isVoid Tests ##

console.assert(_.isVoid(_undefined) === true);

console.assert(_.isVoid(_null) === true);

console.assert(_.isVoid(_true) === false);

console.assert(_.isVoid(_false) === false);

console.assert(_.isVoid(zero) === false);

console.assert(_.isVoid(positiveInteger) === false);

console.assert(_.isVoid(negativeInteger) === false);

console.assert(_.isVoid(positiveFloat) === false);

console.assert(_.isVoid(negativeFloat) === false);

console.assert(_.isVoid(string) === false);

console.assert(_.isVoid(emptyString) === false);

console.assert(_.isVoid(array) === false);

console.assert(_.isVoid(emptyArray) === false);

console.assert(_.isVoid(object) === false);

console.assert(_.isVoid(emptyObject) === false);

console.assert(_.isVoid(funcWithArgs) === false);

console.assert(_.isVoid(funcNoArgs) === false);

console.assert(_.isVoid(Blueprint) === false);

console.assert(_.isVoid(blueprint) === false);

//# isUndefined Tests ##

console.assert(_.isUndefined(_undefined) === true);

console.assert(_.isUndefined(_null) === false);

console.assert(_.isUndefined(_true) === false);

console.assert(_.isUndefined(_false) === false);

console.assert(_.isUndefined(zero) === false);

console.assert(_.isUndefined(positiveInteger) === false);

console.assert(_.isUndefined(negativeInteger) === false);

console.assert(_.isUndefined(positiveFloat) === false);

console.assert(_.isUndefined(negativeFloat) === false);

console.assert(_.isUndefined(string) === false);

console.assert(_.isUndefined(emptyString) === false);

console.assert(_.isUndefined(array) === false);

console.assert(_.isUndefined(emptyArray) === false);

console.assert(_.isUndefined(object) === false);

console.assert(_.isUndefined(emptyObject) === false);

console.assert(_.isUndefined(funcWithArgs) === false);

console.assert(_.isUndefined(funcNoArgs) === false);

console.assert(_.isUndefined(Blueprint) === false);

console.assert(_.isUndefined(blueprint) === false);

//# isNull Tests ##

console.assert(_.isNull(_undefined) === false);

console.assert(_.isNull(_null) === true);

console.assert(_.isNull(_true) === false);

console.assert(_.isNull(_false) === false);

console.assert(_.isNull(zero) === false);

console.assert(_.isNull(positiveInteger) === false);

console.assert(_.isNull(negativeInteger) === false);

console.assert(_.isNull(positiveFloat) === false);

console.assert(_.isNull(negativeFloat) === false);

console.assert(_.isNull(string) === false);

console.assert(_.isNull(emptyString) === false);

console.assert(_.isNull(array) === false);

console.assert(_.isNull(emptyArray) === false);

console.assert(_.isNull(object) === false);

console.assert(_.isNull(emptyObject) === false);

console.assert(_.isNull(funcWithArgs) === false);

console.assert(_.isNull(funcNoArgs) === false);

console.assert(_.isNull(Blueprint) === false);

console.assert(_.isNull(blueprint) === false);

//# isBoolean Tests ##

console.assert(_.isBoolean(_undefined) === false);

console.assert(_.isBoolean(_null) === false);

console.assert(_.isBoolean(_true) === true);

console.assert(_.isBoolean(_false) === true);

console.assert(_.isBoolean(zero) === false);

console.assert(_.isBoolean(positiveInteger) === false);

console.assert(_.isBoolean(negativeInteger) === false);

console.assert(_.isBoolean(positiveFloat) === false);

console.assert(_.isBoolean(negativeFloat) === false);

console.assert(_.isBoolean(string) === false);

console.assert(_.isBoolean(emptyString) === false);

console.assert(_.isBoolean(array) === false);

console.assert(_.isBoolean(emptyArray) === false);

console.assert(_.isBoolean(object) === false);

console.assert(_.isBoolean(emptyObject) === false);

console.assert(_.isBoolean(funcWithArgs) === false);

console.assert(_.isBoolean(funcNoArgs) === false);

console.assert(_.isBoolean(Blueprint) === false);

console.assert(_.isBoolean(blueprint) === false);

//# isTruthy Tests ##

console.assert(_.isTruthy(_undefined) === false);

console.assert(_.isTruthy(_null) === false);

console.assert(_.isTruthy(_true) === true);

console.assert(_.isTruthy(_false) === false);

console.assert(_.isTruthy(zero) === false);

console.assert(_.isTruthy(positiveInteger) === true);

console.assert(_.isTruthy(negativeInteger) === true); // slightly counterintuitive

console.assert(_.isTruthy(positiveFloat) === true);

console.assert(_.isTruthy(negativeFloat) === true); // slightly counterintuitive

console.assert(_.isTruthy(string) === true);

console.assert(_.isTruthy(emptyString) === false);

console.assert(_.isTruthy(array) === true);

console.assert(_.isTruthy(emptyArray) === true); // counterintuitive

console.assert(_.isTruthy(object) === true);

console.assert(_.isTruthy(emptyObject) === true); // counterintuitive

console.assert(_.isTruthy(funcWithArgs) === true);

console.assert(_.isTruthy(funcNoArgs) === true);

console.assert(_.isTruthy(Blueprint) === true);

console.assert(_.isTruthy(blueprint) === true);

//# isFalsey Tests ##

console.assert(_.isFalsey(_undefined) === true);

console.assert(_.isFalsey(_null) === true);

console.assert(_.isFalsey(_true) === false);

console.assert(_.isFalsey(_false) === true);

console.assert(_.isFalsey(zero) === true);

console.assert(_.isFalsey(positiveInteger) === false);

console.assert(_.isFalsey(negativeInteger) === false); // slightly counterintuitive

console.assert(_.isFalsey(positiveFloat) === false);

console.assert(_.isFalsey(negativeFloat) === false); // slightly counterintuitive

console.assert(_.isFalsey(string) === false);

console.assert(_.isFalsey(emptyString) === true);

console.assert(_.isFalsey(array) === false);

console.assert(_.isFalsey(emptyArray) === false); // counterintuitive

console.assert(_.isFalsey(object) === false);

console.assert(_.isFalsey(emptyObject) === false); // counterintuitive

console.assert(_.isFalsey(funcWithArgs) === false);

console.assert(_.isFalsey(funcNoArgs) === false);

console.assert(_.isFalsey(Blueprint) === false);

console.assert(_.isFalsey(blueprint) === false);

//# isNumber Tests ##

console.assert(_.isNumber(_undefined) === false);

console.assert(_.isNumber(_null) === false);

console.assert(_.isNumber(_true) === false);

console.assert(_.isNumber(_false) === false);

console.assert(_.isNumber(zero) === true);

console.assert(_.isNumber(positiveInteger) === true);

console.assert(_.isNumber(negativeInteger) === true);

console.assert(_.isNumber(positiveFloat) === true);

console.assert(_.isNumber(negativeFloat) === true);

console.assert(_.isNumber(string) === false);

console.assert(_.isNumber(emptyString) === false);

console.assert(_.isNumber(array) === false);

console.assert(_.isNumber(emptyArray) === false);

console.assert(_.isNumber(object) === false);

console.assert(_.isNumber(emptyObject) === false);

console.assert(_.isNumber(funcWithArgs) === false);

console.assert(_.isNumber(funcNoArgs) === false);

console.assert(_.isNumber(Blueprint) === false);

console.assert(_.isNumber(blueprint) === false);

//# isZero Tests ##

console.assert(_.isZero(_undefined) === false);

console.assert(_.isZero(_null) === false);

console.assert(_.isZero(_true) === false);

console.assert(_.isZero(_false) === false);

console.assert(_.isZero(zero) === true);

console.assert(_.isZero(positiveInteger) === false);

console.assert(_.isZero(negativeInteger) === false);

console.assert(_.isZero(positiveFloat) === false);

console.assert(_.isZero(negativeFloat) === false);

console.assert(_.isZero(string) === false);

console.assert(_.isZero(emptyString) === false);

console.assert(_.isZero(array) === false);

console.assert(_.isZero(emptyArray) === false);

console.assert(_.isZero(object) === false);

console.assert(_.isZero(emptyObject) === false);

console.assert(_.isZero(funcWithArgs) === false);

console.assert(_.isZero(funcNoArgs) === false);

console.assert(_.isZero(Blueprint) === false);

console.assert(_.isZero(blueprint) === false);

//# isPositive Tests ##

console.assert(_.isPositive(_undefined) === false);

console.assert(_.isPositive(_null) === false);

console.assert(_.isPositive(_true) === false);

console.assert(_.isPositive(_false) === false);

console.assert(_.isPositive(zero) === false);

console.assert(_.isPositive(positiveInteger) === true);

console.assert(_.isPositive(negativeInteger) === false);

console.assert(_.isPositive(positiveFloat) === true);

console.assert(_.isPositive(negativeFloat) === false);

console.assert(_.isPositive(string) === false);

console.assert(_.isPositive(emptyString) === false);

console.assert(_.isPositive(array) === false);

console.assert(_.isPositive(emptyArray) === false);

console.assert(_.isPositive(object) === false);

console.assert(_.isPositive(emptyObject) === false);

console.assert(_.isPositive(funcWithArgs) === false);

console.assert(_.isPositive(funcNoArgs) === false);

console.assert(_.isPositive(Blueprint) === false);

console.assert(_.isPositive(blueprint) === false);

//# isNegative Tests ##

console.assert(_.isNegative(_undefined) === false);

console.assert(_.isNegative(_null) === false);

console.assert(_.isNegative(_true) === false);

console.assert(_.isNegative(_false) === false);

console.assert(_.isNegative(zero) === false);

console.assert(_.isNegative(positiveInteger) === false);

console.assert(_.isNegative(negativeInteger) === true);

console.assert(_.isNegative(positiveFloat) === false);

console.assert(_.isNegative(negativeFloat) === true);

console.assert(_.isNegative(string) === false);

console.assert(_.isNegative(emptyString) === false);

console.assert(_.isNegative(array) === false);

console.assert(_.isNegative(emptyArray) === false);

console.assert(_.isNegative(object) === false);

console.assert(_.isNegative(emptyObject) === false);

console.assert(_.isNegative(funcWithArgs) === false);

console.assert(_.isNegative(funcNoArgs) === false);

console.assert(_.isNegative(Blueprint) === false);

console.assert(_.isNegative(blueprint) === false);

//# isInteger Tests ##

console.assert(_.isInteger(_undefined) === false);

console.assert(_.isInteger(_null) === false);

console.assert(_.isInteger(_true) === false);

console.assert(_.isInteger(_false) === false);

console.assert(_.isInteger(zero) === true);

console.assert(_.isInteger(positiveInteger) === true);

console.assert(_.isInteger(negativeInteger) === true);

console.assert(_.isInteger(positiveFloat) === false);

console.assert(_.isInteger(negativeFloat) === false);

console.assert(_.isInteger(string) === false);

console.assert(_.isInteger(emptyString) === false);

console.assert(_.isInteger(array) === false);

console.assert(_.isInteger(emptyArray) === false);

console.assert(_.isInteger(object) === false);

console.assert(_.isInteger(emptyObject) === false);

console.assert(_.isInteger(funcWithArgs) === false);

console.assert(_.isInteger(funcNoArgs) === false);

console.assert(_.isInteger(Blueprint) === false);

console.assert(_.isInteger(blueprint) === false);

//# isFloat Tests ##

console.assert(_.isFloat(_undefined) === false);

console.assert(_.isFloat(_null) === false);

console.assert(_.isFloat(_true) === false);

console.assert(_.isFloat(_false) === false);

console.assert(_.isFloat(zero) === false);

console.assert(_.isFloat(positiveInteger) === false);

console.assert(_.isFloat(negativeInteger) === false);

console.assert(_.isFloat(positiveFloat) === true);

console.assert(_.isFloat(negativeFloat) === true);

console.assert(_.isFloat(string) === false);

console.assert(_.isFloat(emptyString) === false);

console.assert(_.isFloat(array) === false);

console.assert(_.isFloat(emptyArray) === false);

console.assert(_.isFloat(object) === false);

console.assert(_.isFloat(emptyObject) === false);

console.assert(_.isFloat(funcWithArgs) === false);

console.assert(_.isFloat(funcNoArgs) === false);

console.assert(_.isFloat(Blueprint) === false);

console.assert(_.isFloat(blueprint) === false);

//# isString Tests ##

console.assert(_.isString(_undefined) === false);

console.assert(_.isString(_null) === false);

console.assert(_.isString(_true) === false);

console.assert(_.isString(_false) === false);

console.assert(_.isString(zero) === false);

console.assert(_.isString(positiveInteger) === false);

console.assert(_.isString(negativeInteger) === false);

console.assert(_.isString(positiveFloat) === false);

console.assert(_.isString(negativeFloat) === false);

console.assert(_.isString(string) === true);

console.assert(_.isString(emptyString) === true);

console.assert(_.isString(array) === false);

console.assert(_.isString(emptyArray) === false);

console.assert(_.isString(object) === false);

console.assert(_.isString(emptyObject) === false);

console.assert(_.isString(funcWithArgs) === false);

console.assert(_.isString(funcNoArgs) === false);

console.assert(_.isString(Blueprint) === false);

console.assert(_.isString(blueprint) === false);

//# isArray Tests ##

console.assert(_.isArray(_undefined) === false);

console.assert(_.isArray(_null) === false);

console.assert(_.isArray(_true) === false);

console.assert(_.isArray(_false) === false);

console.assert(_.isArray(zero) === false);

console.assert(_.isArray(positiveInteger) === false);

console.assert(_.isArray(negativeInteger) === false);

console.assert(_.isArray(positiveFloat) === false);

console.assert(_.isArray(negativeFloat) === false);

console.assert(_.isArray(string) === false);

console.assert(_.isArray(emptyString) === false);

console.assert(_.isArray(array) === true);

console.assert(_.isArray(emptyArray) === true);

console.assert(_.isArray(object) === false);

console.assert(_.isArray(emptyObject) === false);

console.assert(_.isArray(funcWithArgs) === false);

console.assert(_.isArray(funcNoArgs) === false);

console.assert(_.isArray(Blueprint) === false);

console.assert(_.isArray(blueprint) === false);

//# isObject Tests ##

console.assert(_.isObject(_undefined) === false);

console.assert(_.isObject(_null) === false);

console.assert(_.isObject(_true) === false);

console.assert(_.isObject(_false) === false);

console.assert(_.isObject(zero) === false);

console.assert(_.isObject(positiveInteger) === false);

console.assert(_.isObject(negativeInteger) === false);

console.assert(_.isObject(positiveFloat) === false);

console.assert(_.isObject(negativeFloat) === false);

console.assert(_.isObject(string) === false);

console.assert(_.isObject(emptyString) === false);

console.assert(_.isObject(array) === false);

console.assert(_.isObject(emptyArray) === false);

console.assert(_.isObject(object) === true);

console.assert(_.isObject(emptyObject) === true);

console.assert(_.isObject(funcWithArgs) === false);

console.assert(_.isObject(funcNoArgs) === false);

console.assert(_.isObject(Blueprint) === false);

console.assert(_.isObject(blueprint) === true); // slightly counterintuitive

//# isFunction Tests ##

console.assert(_.isFunction(_undefined) === false);

console.assert(_.isFunction(_null) === false);

console.assert(_.isFunction(_true) === false);

console.assert(_.isFunction(_false) === false);

console.assert(_.isFunction(zero) === false);

console.assert(_.isFunction(positiveInteger) === false);

console.assert(_.isFunction(negativeInteger) === false);

console.assert(_.isFunction(positiveFloat) === false);

console.assert(_.isFunction(negativeFloat) === false);

console.assert(_.isFunction(string) === false);

console.assert(_.isFunction(emptyString) === false);

console.assert(_.isFunction(array) === false);

console.assert(_.isFunction(emptyArray) === false);

console.assert(_.isFunction(object) === false);

console.assert(_.isFunction(emptyObject) === false);

console.assert(_.isFunction(funcWithArgs) === true);

console.assert(_.isFunction(funcNoArgs) === true);

console.assert(_.isFunction(Blueprint) === true); // counterintuitive

console.assert(_.isFunction(blueprint) === false);

//# isBlueprint Tests ##

console.assert(_.isBlueprint(_undefined) === false);

console.assert(_.isBlueprint(_null) === false);

console.assert(_.isBlueprint(_true) === false);

console.assert(_.isBlueprint(_false) === false);

console.assert(_.isBlueprint(zero) === false);

console.assert(_.isBlueprint(positiveInteger) === false);

console.assert(_.isBlueprint(negativeInteger) === false);

console.assert(_.isBlueprint(positiveFloat) === false);

console.assert(_.isBlueprint(negativeFloat) === false);

console.assert(_.isBlueprint(string) === false);

console.assert(_.isBlueprint(emptyString) === false);

console.assert(_.isBlueprint(array) === false);

console.assert(_.isBlueprint(emptyArray) === false);

console.assert(_.isBlueprint(object) === false);

console.assert(_.isBlueprint(emptyObject) === false);

console.assert(_.isBlueprint(funcWithArgs) === false);

console.assert(_.isBlueprint(funcNoArgs) === false);

console.assert(_.isBlueprint(Blueprint) === true);

console.assert(_.isBlueprint(blueprint) === false);

//# isClass Tests ##

console.assert(_.isClass(_undefined) === false);

console.assert(_.isClass(_null) === false);

console.assert(_.isClass(_true) === false);

console.assert(_.isClass(_false) === false);

console.assert(_.isClass(zero) === false);

console.assert(_.isClass(positiveInteger) === false);

console.assert(_.isClass(negativeInteger) === false);

console.assert(_.isClass(positiveFloat) === false);

console.assert(_.isClass(negativeFloat) === false);

console.assert(_.isClass(string) === false);

console.assert(_.isClass(emptyString) === false);

console.assert(_.isClass(array) === false);

console.assert(_.isClass(emptyArray) === false);

console.assert(_.isClass(object) === false);

console.assert(_.isClass(emptyObject) === false);

console.assert(_.isClass(funcWithArgs) === false);

console.assert(_.isClass(funcNoArgs) === false);

console.assert(_.isClass(Blueprint) === false);

console.assert(_.isClass(blueprint) === true);

Could also add NaN function and tests.