refactor: make anys explicit

packages/core/src/composition/compose/index.ts

@@ -4,7 +4,7 @@ import type { ExplicitAny, UnaryFunction } from '@/types';
 
 // If its a list of functions, last being Unary
 type ComposeParams<Fns> = Fns extends readonly [
-  ...ExplicitAny[],
+  ...ExplicitAny,
   infer Last extends UnaryFunction,
 ]
   ? // Get Params of the last, which returns [...argTypes], so get the first one [0]

packages/core/src/composition/curry/index.ts

@@ -1,6 +1,6 @@
 // https://github.com/type-challenges/type-challenges/issues/15988
 
-import type { ExplicitAny } from '@/types';
+import type { Callable, ExplicitAny } from '@/types';
 
 export type Curried<T extends unknown[], R> = <P extends Partial<T>>(
   ...args: P
@@ -22,9 +22,9 @@ export type Curried<T extends unknown[], R> = <P extends Partial<T>>(
  * curried(2)(3, 4);
  * curried(2, 3, 4);
  */
-export function autoCurry<T extends (...args: ExplicitAny[]) => ExplicitAny>(
+export function autoCurry<T extends Callable>(
   fn: T,
-  _args = [] as ExplicitAny[],
+  _args = [] as ExplicitAny,
 ): Curried<Parameters<T>, ReturnType<T>> {
   return (...__args) =>
     ((rest) => (rest.length >= fn.length ? fn(...rest) : autoCurry(fn, rest)))([

packages/core/src/composition/pipe/index.ts

@@ -3,7 +3,7 @@ import type { ExplicitAny, UnaryFunction } from '@/types';
 // If its a list of functions, last being Unary
 type PipeParams<Fns> = Fns extends readonly [
   infer First extends UnaryFunction,
-  ...ExplicitAny[],
+  ...ExplicitAny,
 ]
   ? // Get Params of the first, which returns [...argTypes], so get the first one [0]
     // so that we have the true type of the arg
@@ -14,7 +14,7 @@ type PipeParams<Fns> = Fns extends readonly [
 // have to spread and infer last so that it gets the right type for the last one
 // [-1] no bueno
 type PipeReturn<Fns> = ReturnType<
-  Fns extends readonly [...ExplicitAny[], infer Last extends UnaryFunction]
+  Fns extends readonly [...ExplicitAny, infer Last extends UnaryFunction]
     ? Last
     : never
 >;

packages/core/src/types.ts

@@ -2,6 +2,8 @@ export type Accumulator<T, R> = (acc: R, x: T) => R;
 
 export type ArrayElementType<T> = T extends (infer E)[] ? E : T;
 
+export type Callable = (...all: ExplicitAny) => ExplicitAny;
+
 export type Comparator<T> = (x: T) => boolean;
 
 // biome-ignore lint/suspicious/noExplicitAny: <explanation>

packages/core/src/utility/lookup/index.ts

@@ -1,6 +1,8 @@
-import type { ExplicitAny } from '@/types';
+import type { Callable } from '@/types';
 import { identity } from '../../combinators/i';
 
+type Cache = Record<string | number | symbol, unknown>;
+
 /**
  * Takes an object and an optional fallback function and returns a function that
  * takes a string and returns the lookup value or the result default fallback.
@@ -17,15 +19,6 @@ import { identity } from '../../combinators/i';
  * colorLookup(data.value);
  */
 export const lookup =
-  <
-    A extends Record<string | number | symbol, unknown>,
-    B extends (...args: ExplicitAny[]) => ExplicitAny,
-  >(
-    obj: A,
-    def?: B,
-  ) =>
-  <C extends keyof A>(prop: string | number | symbol): A[C] => {
-    const fn = def ?? identity;
-
-    return fn(obj[prop]);
-  };
+  <A extends Cache, B extends Callable>(obj: A, def?: B) =>
+  <C extends keyof A>(prop: string | number | symbol): A[C] =>
+    (def ?? identity)(obj[prop]);

packages/core/src/utility/once/index.ts

@@ -1,18 +1,16 @@
-import type { ExplicitAny } from '@/types';
-
-// TS' `Function` type only models the object side of it, not whether it is callable.
-type SomeFunction = (...args: ExplicitAny[]) => ExplicitAny;
+import type { Callable } from '@/types';
 
 /**
  * Ensures that the given function is only called once.
  */
-export const once = <T extends SomeFunction>(fn: T) => {
+export const once = <T extends Callable>(fn: T) => {
   let done = false;
 
-  // TODO: Better types, since it can return void?
-  // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>
-  return (...args: Parameters<T>): ReturnType<T> | void =>
-    // biome-ignore lint/suspicious/noAssignInExpressions: Shhhh
-    // biome-ignore lint/style/noCommaOperator: Shhh
-    done ? void 0 : ((done = true), fn(args));
+  return (...args: Parameters<T>): ReturnType<T> | undefined => {
+    if (!done) {
+      done = true;
+
+      return fn(...args);
+    }
+  };
 };