refactor: 타입 가드 함수의 추론 결과 개선

src/Lazy/dropRight.ts

@@ -8,9 +8,7 @@ import concurrent, { isConcurrent } from "./concurrent";
 function* sync<T>(length: number, iterable: Iterable<T>) {
   const arr =
     isArray(iterable) || isString(iterable) ? iterable : toArray(iterable);
-  for (let i = 0; i < arr.length - length; i++) {
-    yield arr[i];
-  }
+  for (let i = 0; i < arr.length - length; i++) yield arr[i] as T;
 }
 
 async function* asyncSequential<T>(length: number, iterable: AsyncIterable<T>) {

src/Lazy/takeRight.ts

@@ -11,17 +11,16 @@ function* sync<A>(length: number, iterable: Iterable<A>): IterableIterator<A> {
     isArray(iterable) || isString(iterable) ? iterable : toArray(iterable);
   const index = arr.length - length;
   for (let i = index; i < arr.length; i++) {
-    if (arr[i]) yield arr[i];
+    isIterable(iterable);
+    if (arr[i]) yield arr[i] as A;
   }
 }
 
 async function* asyncSequential<T>(length: number, iterable: AsyncIterable<T>) {
   const arr = await toArray(iterable);
   const index = arr.length - length;
   for (let i = index; i < arr.length; i++) {
-    if (arr[i]) {
-      yield arr[i];
-    }
+    if (arr[i]) yield arr[i];
   }
 }
 

src/isArray.ts

@@ -1,5 +1,3 @@
-import type Include from "./types/Include";
-
 /**
  * Returns true if `a` is an Array.
  *
@@ -9,7 +7,7 @@ import type Include from "./types/Include";
  * isArray(2); // false
  * ```
  */
-const isArray = <T>(a: T): a is Include<T, unknown[] | Readonly<unknown[]>> =>
-  Array.isArray(a);
+const isArray = (input: unknown): input is unknown[] | Readonly<unknown[]> =>
+  Array.isArray(input);
 
 export default isArray;

src/isBoolean.ts

@@ -1,5 +1,3 @@
-import type Include from "./types/Include";
-
 /**
  * Returns true if `n` is a Boolean.
  *
@@ -10,6 +8,6 @@ import type Include from "./types/Include";
  * isBoolean("FxTS"); // false
  * ```
  */
-const isBoolean = <T>(n: T): n is Include<T, boolean> => typeof n === "boolean";
-
+const isBoolean = (input: unknown): input is boolean =>
+  typeof input === "boolean";
 export default isBoolean;

src/isNil.ts

@@ -1,6 +1,5 @@
 import isNull from "./isNull";
 import isUndefined from "./isUndefined";
-import type Include from "./types/Include";
 
 /**
  * Checks if the given value is `null` or `undefined`.
@@ -13,7 +12,6 @@ import type Include from "./types/Include";
  * isNil(null); // true
  * ```
  */
-const isNil = <T>(a: T): a is Include<T, null | undefined> =>
-  isUndefined(a) || isNull(a);
-
+const isNil = (input: unknown): input is null | undefined =>
+  isUndefined(input) || isNull(input);
 export default isNil;

src/isNull.ts

@@ -1,5 +1,3 @@
-import type Include from "./types/Include";
-
 /**
  * Checks if the given value is `null`.
  *
@@ -11,6 +9,6 @@ import type Include from "./types/Include";
  * isNull(null); // true
  * ```
  */
-const isNull = <T>(input: T): input is Include<T, null> => input === null;
+const isNull = (input: unknown): input is null => input === null;
 
 export default isNull;

src/isNumber.ts

@@ -1,5 +1,3 @@
-import type Include from "./types/Include";
-
 /**
  * Returns true if `n` is a Number.
  *
@@ -9,6 +7,5 @@ import type Include from "./types/Include";
  * isNumber("a"); // false
  * ```
  */
-const isNumber = <T>(n: T): n is Include<T, number> => typeof n === "number";
-
+const isNumber = (input: unknown): input is number => typeof input === "number";
 export default isNumber;

src/isObject.ts

@@ -1,4 +1,4 @@
-import type Include from "./types/Include";
+import isNull from "./isNull";
 
 /**
  * Checks if value is the type of object.
@@ -12,9 +12,9 @@ import type Include from "./types/Include";
  * isObject(123); // false
  * ```
  */
-const isObject = <T>(a: T): a is Include<T, object> => {
-  const type = typeof a;
-  return a != null && (type === "object" || type === "function");
+const isObject = (input: unknown): input is object => {
+  const type = typeof input;
+  return !isNull(input) && (type === "object" || type === "function");
 };
 
 export default isObject;

src/isString.ts

@@ -1,5 +1,3 @@
-import type Include from "./types/Include";
-
 /**
  * Returns true if `s` is a String.
  *
@@ -9,6 +7,5 @@ import type Include from "./types/Include";
  * isString(2); // false
  * ```
  */
-const isString = <T>(s: T): s is Include<T, string> => typeof s === "string";
-
+const isString = (input: unknown): input is string => typeof input === "string";
 export default isString;

src/isUndefined.ts

@@ -1,5 +1,3 @@
-import type Include from "./types/Include";
-
 /**
  * Checks if the given value is `undefined`.
  *
@@ -9,6 +7,6 @@ import type Include from "./types/Include";
  * isUndefined(2); // false
  * ```
  */
-const isUndefined = <T>(a: T): a is Include<T, undefined> => a === undefined;
+const isUndefined = (input: unknown): input is undefined => input === undefined;
 
 export default isUndefined;