From 23b1e225b4dc78e9a85770800e11a63f780a794b Mon Sep 17 00:00:00 2001
From: Kodie Grantham <kodie.grantham@gmail.com>
Date: Fri, 6 Oct 2017 13:18:03 -0500
Subject: [PATCH] Correct is.any() and is.all() methods

---
 index.js  | 109 ++++--------------------------------------------------
 readme.md |  16 ++++----
 test.js   |  20 ++++------
 3 files changed, 24 insertions(+), 121 deletions(-)

diff --git a/index.js b/index.js
index 3376e21..6d265b2 100644
--- a/index.js
+++ b/index.js
@@ -169,118 +169,25 @@ const isEmptyMapOrSet = x => (is.map(x) || is.set(x)) && x.size === 0;
 
 is.empty = x => !x || isEmptyStringOrArray(x) || isEmptyObject(x) || isEmptyMapOrSet(x);
 
-const isType = (value, type) => {
-	switch (String(type).toLowerCase()) {
-		case 'undefined':
-			return is.undefined(value);
-		case 'null':
-			return is.null(value);
-		case 'string':
-			return is.string(value);
-		case 'number':
-			return is.number(value);
-		case 'boolean':
-			return is.boolean(value);
-		case 'symbol':
-			return is.symbol(value);
-		case 'array':
-			return is.array(value);
-		case 'function':
-			return is.function(value);
-		case 'buffer':
-			return is.buffer(value);
-		case 'object':
-			return is.object(value);
-		case 'regexp':
-			return is.regExp(value);
-		case 'date':
-			return is.date(value);
-		case 'error':
-			return is.error(value);
-		case 'nativepromise':
-			return is.nativePromise(value);
-		case 'promise':
-			return is.promise(value);
-		case 'generator':
-			return is.generator(value);
-		case 'generatorfunction':
-			return is.generatorFunction(value);
-		case 'map':
-			return is.map(value);
-		case 'set':
-			return is.set(value);
-		case 'weakmap':
-			return is.weakMap(value);
-		case 'weakset':
-			return is.weakSet(value);
-		case 'int8array':
-			return is.int8Array(value);
-		case 'uint8array':
-			return is.uint8Array(value);
-		case 'uint8clampedarray':
-			return is.uint8ClampedArray(value);
-		case 'int16array':
-			return is.int16Array(value);
-		case 'uint16array':
-			return is.uint16Array(value);
-		case 'int32array':
-			return is.int32Array(value);
-		case 'uint32array':
-			return is.uint32Array(value);
-		case 'float32array':
-			return is.float32Array(value);
-		case 'float64arrat':
-			return is.float64Array(value);
-		case 'arraybuffer':
-			return is.arrayBuffer(value);
-		case 'sharedarraybuffer':
-			return is.sharedArrayBuffer(value);
-		case 'dataview':
-			return is.dataView(value);
-		case 'nan':
-			return is.nan(value);
-		case 'nullorundefined':
-			return is.nullOrUndefined(value);
-		case 'primitive':
-			return is.primitive(value);
-		case 'integer':
-			return is.integer(value);
-		case 'plainobject':
-			return is.plainObject(value);
-		case 'iterable':
-			return is.iterable(value);
-		case 'class':
-			return is.class(value);
-		case 'typedarray':
-			return is.typedArray(value);
-		default:
-			return false;
-	}
-};
-
-is.any = (values, types) => {
+is.any = (predicate, ...values) => {
 	let ret = false;
 
 	values.forEach(value => {
-		types.forEach(type => {
-			if (isType(value, type)) {
-				ret = true;
-			}
-		});
+		if (predicate(value)) {
+			ret = true;
+		}
 	});
 
 	return ret;
 };
 
-is.all = (values, types) => {
+is.all = (predicate, ...values) => {
 	let ret = true;
 
 	values.forEach(value => {
-		types.forEach(type => {
-			if (!isType(value, type)) {
-				ret = false;
-			}
-		});
+		if (!predicate(value)) {
+			ret = false;
+		}
 	});
 
 	return ret;
diff --git a/readme.md b/readme.md
index 6bd2560..875de2a 100644
--- a/readme.md
+++ b/readme.md
@@ -155,27 +155,27 @@ Check if `value` is `Infinity` or `-Infinity`.
 Returns `true` if `value` is falsy or an empty string, array, object, map, or set.
 
 
-##### .any(values, types)
+##### .any(predicate, ...values)
 
-Returns `true` if **any** of `values`'s (array) types are in `types` (array).
+Returns `true` if **any** of the input `values` returns true in the `predicate`:
 
 ```js
-is.any(['🦄', {}], ['string', 'boolean']);
+is.any(is.string, {}, true, '🦄');
 //=> true
 
-is.any([[], {}], ['null', 'integer']);
+is.any(is.boolean, 'unicorns', [], new Map());
 //=> false
 ```
 
-##### .all(values, types)
+##### .all(predicate, ...values)
 
-Returns `true` if **all** of `values`'s (array) types are in `types` (array).
+Returns `true` if **all** of the input `values` returns true in the `predicate`:
 
 ```js
-is.all([new Set(), new Map(), {}], ['object']);
+is.all(is.object, {}, new Map(), new Set());
 //=> true
 
-is.all([false, '🦄'], ['string', 'array']);
+is.all(is.string, '🦄', [], 'unicorns');
 //=> false
 ```
 
diff --git a/test.js b/test.js
index 676bcba..e2107bb 100644
--- a/test.js
+++ b/test.js
@@ -404,19 +404,15 @@ test('is.empty', t => {
 });
 
 test('is.any', t => {
-	t.true(m.any([null, false], ['null', 'object']));
-	t.true(m.any(['🦄', []], ['array', 'boolean']));
-	t.true(m.any([{}, []], ['object', 'string']));
-	t.false(m.any([null, []], ['string', 'set']));
-	t.false(m.any([new Set(), true], ['map', 'string']));
-	t.false(m.any(['🦄', null], ['set', 'boolean']));
+	t.true(m.any(m.string, {}, true, '🦄'));
+	t.true(m.any(m.object, false, {}, 'unicorns'));
+	t.false(m.any(m.boolean, '🦄', [], 3));
+	t.false(m.any(m.integer, true, 'lol', {}));
 });
 
 test('is.all', t => {
-	t.true(m.all([() => {}, {}], ['object']));
-	t.true(m.all(['🦄', 'unicorns'], ['string']));
-	t.true(m.any([new Set()], ['object', 'set']));
-	t.false(m.any([null, []], ['string', 'set']));
-	t.false(m.any([new Set(), true], ['map', 'string']));
-	t.false(m.any(['🦄', null], ['set', 'boolean']));
+	t.true(m.all(m.object, {}, new Set(), new Map()));
+	t.true(m.all(m.boolean, true, false));
+	t.false(m.all(m.string, '🦄', []));
+	t.false(m.all(m.set, new Map(), {}));
 });