Stop using temporal heap allocated variables

src/array-of.ts

@@ -32,11 +32,25 @@ const ArrayOf = <
 >(
   guards: G | ((self: NonCallable<Guard<T>>) => G)
 ): Guard<T> => {
-  const isArrayOf = (value: unknown): value is T => {
-    return (
-      isArray(value) &&
-      value.every((value) => generatedGuards.some((guard) => guard(value)))
-    );
+  const isArrayOf = (arr: unknown): arr is T => {
+    if(!isArray(arr)){
+      return false;
+    }
+    for (let i = 0; i < arr.length; i++) {
+      const value = arr[i];
+      let valuePasses = false;
+      for (let i = 0; i < generatedGuards.length; i++) {
+        const guard = generatedGuards[i]!;
+        if (guard(value)) {
+          valuePasses = true;
+          break;
+        }
+      }
+      if (!valuePasses) {
+        return false;
+      }
+    }
+    return true
   };
 
   const generatedGuards =

src/instance-of.ts

@@ -28,7 +28,13 @@ const InstanceOf = <
   constructors: C
 ): Guard<T> => {
   return (value: unknown): value is T => {
-    return constructors.some((constructor) => value instanceof constructor);
+    for (let i = 0; i < constructors.length; i++) {
+      const constructor = constructors[i]!;
+      if(value instanceof constructor){
+        return true
+      }      
+    }
+    return false
   };
 };
 

src/object-of.ts

@@ -70,13 +70,25 @@ const ObjectOf = <
 >(
   guards: G | ((self: NonCallable<Guard<T>>) => G)
 ): Guard<T> => {
-  const isObjectOf = (obj: unknown): obj is T =>
-    isObject(obj) &&
-    Object.entries(generatedGuards).every(([key, guard]) =>
-      guard.optional
+  const isObjectOf = (obj: unknown): obj is T => {
+    if (!isObject(obj)) {
+      return false;
+    }
+    for (const key in generatedGuards) {
+      if (!generatedGuards.hasOwnProperty(key)) {
+        break;
+      }
+      const guard = generatedGuards[key]!;
+      const passes = guard.optional
         ? obj[key] === undefined || guard(obj[key])
-        : key in obj && guard(obj[key])
-    );
+        : key in obj && guard(obj[key]);
+
+      if (!passes) {
+        return false;
+      }
+    }
+    return true;
+  };
 
   const generatedGuards =
     typeof guards === "function"

src/one-of.ts

@@ -29,7 +29,13 @@ const OneOf = <
   guards: G | ((self: NonCallable<Guard<T>>) => G)
 ): Guard<T> => {
   const isOneOf = (value: unknown): value is T => {
-    return generatedGuards.some((guard) => guard(value));
+    for (let i = 0; i < generatedGuards.length; i++) {
+      const guard = generatedGuards[i]!;
+      if (guard(value)) {
+        return true
+      }
+    }
+    return false;
   };
 
   const generatedGuards =

src/record-of.ts

@@ -26,10 +26,28 @@ const RecordOf = <
   guards: G | ((self: NonCallable<Guard<T>>) => G)
 ): Guard<T> => {
   const isRecordOf = (rec: unknown): rec is T => {
-    return (
-      isObject(rec) &&
-      Object.values(rec).every((v) => generatedGuards.some((guard) => guard(v)))
-    );
+    if (!isObject(rec)) {
+      return false;
+    }
+
+    for (const key in rec) {
+      if (!rec.hasOwnProperty(key)) {
+        break;
+      }
+      const value = rec[key];
+      let valuePasses = false;
+      for (let i = 0; i < generatedGuards.length; i++) {
+        const guard = generatedGuards[i]!;
+        if (guard(value)) {
+          valuePasses = true;
+          break;
+        }
+      }
+      if (!valuePasses) {
+        return false;
+      }
+    }
+    return true;
   };
 
   const generatedGuards =

src/tuple-of.ts

@@ -77,14 +77,19 @@ const TupleOf = <
     | ((self: NonCallable<Guard<T>>) => OptionalRequiredGuards<G>)
 ): Guard<T> => {
   const isTupleOf = (tuple: unknown): tuple is T => {
-    return (
-      isArray(tuple) &&
-      tuple.length <= generatedGuards.length &&
-      generatedGuards.every(
-        (guard, i) =>
-          (guard.optional && tuple[i] === undefined) || guard(tuple[i])
-      )
-    );
+    if(!isArray(tuple) || tuple.length > generatedGuards.length){
+      return false;
+    }
+
+    for (let i = 0; i < generatedGuards.length; i++) {
+      const guard = generatedGuards[i]!;
+
+      const passes = (guard.optional && tuple[i] === undefined) || guard(tuple[i])
+      if(!passes){
+        return false
+      }
+    }
+    return true;
   };
 
   const generatedGuards =

src/value-of.ts

@@ -12,7 +12,13 @@ const ValueOf = <const G extends readonly any[] | any[]>(
   expectedValues: G
 ): Guard<G[number]> => {
   return (value: unknown): value is G[number] => {
-    return expectedValues.some((expected) => value === expected);
+    for (let i = 0; i < expectedValues.length; i++) {
+      const expected = expectedValues[i];
+      if(value === expected) {
+        return true
+      }
+    }
+    return false;
   };
 };