smart-filter

Author: uriva

src/composition.ts

@@ -1,5 +1,5 @@
 import { reverse } from "./array.ts";
-import { ComposeMany } from "./composeTyping.ts";
+import type { ComposeMany } from "./composeTyping.ts";
 import { not } from "./operator.ts";
 import { isPromise } from "./promise.ts";
 import { reduce } from "./reduce.ts";

src/filter.test.ts

@@ -19,12 +19,16 @@ Deno.test("async filter", async () => {
 });
 
 const _nums: number[] = remove((x: number) => x > 0)([1, 2, 3]);
+
 // @ts-expect-error should preserve typing information
 const _strings: string[] = remove((x: number) => x > 0)([1, 2, 3]);
+
 const _strings_promise: Promise<number[]> = remove((x: number) =>
   Promise.resolve(x > 0)
 )([1, 2, 3]);
 
+const _predicateTyping: 1[] = filter((x: number) => x == 1)([1, 2, 3]);
+
 Deno.test("async filter", async () => {
   assertEquals(
     await remove((arg: number) => wrapPromise(arg % 2 === 0))([

src/filter.ts

@@ -1,14 +1,18 @@
-import type { Func, IsAsync, ParamOf } from "./typing.ts";
-import { complement, pipe } from "./composition.ts";
 import { head, second } from "./array.ts";
-
-import { map } from "./map.ts";
+import { complement, pipe } from "./composition.ts";
 import { pairRight } from "./juxt.ts";
+import { map } from "./map.ts";
 import { isPromise } from "./promise.ts";
+import type { Func, IsAsync, ParamOf } from "./typing.ts";
+
+type ConstrainedTyping<F extends Func> = F extends
+  ((value: ParamOf<F>) => value is infer S) ? S[]
+  : ParamOf<F>[];
 
 export const filter = <F extends Func>(f: F): (
   _: ParamOf<F>[],
-) => true extends IsAsync<F> ? Promise<ParamOf<F>[]> : ParamOf<F>[] =>
+) => true extends IsAsync<F> ? Promise<ConstrainedTyping<F>>
+  : ConstrainedTyping<F> =>
   // @ts-expect-error typing head is hard.
   pipe(
     map(pairRight(f)),

src/juxt.ts

@@ -1,5 +1,7 @@
 import { allmap, anymap, concat, zip } from "./array.ts";
 import { identity, pipe } from "./composition.ts";
+import { isPromise } from "./promise.ts";
+import { map } from "./map.ts";
 import type {
   AnyAsync,
   Func,
@@ -8,9 +10,6 @@ import type {
   Union,
 } from "./typing.ts";
 
-import { map } from "./map.ts";
-import { isPromise } from "./index.ts";
-
 type Results<Functions extends Func[]> = {
   [i in keyof Functions]: ReturnTypeUnwrapped<Functions[i]>;
 };

src/map.ts

@@ -1,5 +1,4 @@
 import type { IsAsync, Unary, UnaryFnUntyped } from "./typing.ts";
-
 import { errorBoundry, pipe } from "./composition.ts";
 import { reduce } from "./reduce.ts";
 import { isPromise } from "./promise.ts";

src/mapping.ts

@@ -1,5 +1,10 @@
+import { head, second, wrapArray } from "./array.ts";
+import { applyTo, identity, pipe } from "./composition.ts";
+import { filter } from "./filter.ts";
+import { stack } from "./juxt.ts";
+import { map } from "./map.ts";
+import { reduce } from "./reduce.ts";
 import type {
-  AsyncFunction,
   ElementOf,
   Func,
   IsAsync,
@@ -8,13 +13,6 @@ import type {
   ReturnTypeUnwrapped,
   Unary,
 } from "./typing.ts";
-import { applyTo, identity, pipe } from "./composition.ts";
-import { head, second, wrapArray } from "./array.ts";
-
-import { filter } from "./filter.ts";
-import { map } from "./map.ts";
-import { reduce } from "./reduce.ts";
-import { stack } from "./juxt.ts";
 
 export const wrapObject = <V>(key: string) => (value: V) => ({ [key]: value });
 
@@ -115,12 +113,7 @@ const onEntries = <
 
 export const entryMap = pipe(map, onEntries);
 
-export const entryFilter = <
-  Function extends (
-    // deno-lint-ignore no-explicit-any
-    ((kv: [any, any]) => any)
-  ),
->(f: Function) => onEntries(filter(f));
+export const entryFilter = pipe(filter, onEntries);
 
 type RecordKey = string | number | symbol;
 type EntryMap<