123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218
/** * Filterable is a structure that allows one to remove or refine a data * structure. * * @module Filterable * @since 2.0.0 */
import type { $, Hold, Kind } from "./kind.ts";import type { Either } from "./either.ts";import type { Mappable } from "./mappable.ts";import type { Option } from "./option.ts";import type { Pair } from "./pair.ts";import type { Predicate } from "./predicate.ts";import type { Refinement } from "./refinement.ts";
import { getLeft, getRight } from "./either.ts";import { flow, pipe } from "./fn.ts";
/** * A Filterable structure allows one to filter over the values contained in the * structure. This includes standard filter, filterMap, partition, and * partitionMap. * * @since 2.0.0 */export interface Filterable<U extends Kind> extends Hold<U> {  readonly filter: {    <A, I extends A>(      refinement: Refinement<A, I>,    ): <B = never, C = never, D = unknown, E = unknown>(      ta: $<U, [A, B, C], [D], [E]>,    ) => $<U, [I, B, C], [D], [E]>;    <A>(      predicate: Predicate<A>,    ): <B = never, C = never, D = unknown, E = unknown>(      ta: $<U, [A, B, C], [D], [E]>,    ) => $<U, [A, B, C], [D], [E]>;  };  readonly filterMap: <A, I>(    fai: (a: A) => Option<I>,  ) => <B = never, C = never, D = unknown, E = unknown>(    ua: $<U, [A, B, C], [D], [E]>,  ) => $<U, [I, B, C], [D], [E]>;  readonly partition: {    <A, I extends A>(      refinement: Refinement<A, I>,    ): <B = never, C = never, D = unknown, E = unknown>(      ta: $<U, [A, B, C], [D], [E]>,    ) => Pair<$<U, [I, B, C], [D], [E]>, $<U, [A, B, C], [D], [E]>>;    <A>(      predicate: Predicate<A>,    ): <B = never, C = never, D = unknown, E = unknown>(      ta: $<U, [A, B, C], [D], [E]>,    ) => Pair<$<U, [A, B, C], [D], [E]>, $<U, [A, B, C], [D], [E]>>;  };  readonly partitionMap: <A, I, J>(    fai: (a: A) => Either<J, I>,  ) => <B = never, C = never, D = unknown, E = unknown>(    ua: $<U, [A, B, C], [D], [E]>,  ) => Pair<$<U, [I, B, C], [D], [E]>, $<U, [J, B, C], [D], [E]>>;}
/** * @since 2.0.0 */export function filter<U extends Kind, V extends Kind>(  { map }: Mappable<U>,  { filter }: Filterable<V>,): <A>(  predicate: Predicate<A>,) => <  B = never,  C = never,  D = unknown,  E = unknown,  J = never,  K = never,  L = unknown,  M = unknown,>(  ua: $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>,) => $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]> {  return (predicate) => (uva) => pipe(uva, map(filter(predicate)));}
/** * @since 2.0.0 */export function filterMap<U extends Kind, V extends Kind>(  { map }: Mappable<U>,  { filterMap }: Filterable<V>,): <A, I>(  predicate: (a: A) => Option<I>,) => <  B = never,  C = never,  D = unknown,  E = unknown,  J = never,  K = never,  L = unknown,  M = unknown,>(  ua: $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>,) => $<U, [$<V, [I, B, C], [D], [E]>, J, K], [L], [M]> {  return (predicate) => (uva) => pipe(uva, map(filterMap(predicate)));}
/** * @since 2.0.0 */export function partition<U extends Kind, V extends Kind>(  M: Mappable<U>,  F: Filterable<V>,): <A, I extends A>(  predicate: Refinement<A, I>,) => <  B = never,  C = never,  D = unknown,  E = unknown,  J = never,  K = never,  L = unknown,  M = unknown,>(  ua: $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>,) => Pair<  $<U, [$<V, [I, B, C], [D], [E]>, J, K], [L], [M]>,  $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>>;export function partition<U extends Kind, V extends Kind>(  M: Mappable<U>,  F: Filterable<V>,): <A>(  predicate: Predicate<A>,) => <  B = never,  C = never,  D = unknown,  E = unknown,  J = never,  K = never,  L = unknown,  M = unknown,>(  ua: $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>,) => Pair<  $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>,  $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>>;export function partition<U extends Kind, V extends Kind>(  M: Mappable<U>,  F: Filterable<V>,): <A>(  predicate: Predicate<A>,) => <  B = never,  C = never,  D = unknown,  E = unknown,  J = never,  K = never,  L = unknown,  M = unknown,>(  ua: $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>,) => Pair<  $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>,  $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>> {  const _filter = filter(M, F);  // TODO: Figure this overload out :/  return (predicate) => {    // deno-lint-ignore no-explicit-any    const first = _filter(predicate as any);    // deno-lint-ignore no-explicit-any    const second = _filter(((a: any) => !predicate(a)) as any);    // deno-lint-ignore no-explicit-any    return (uva) => [first(uva), second(uva)] as any;  };}
/** * @since 2.0.0 */export function partitionMap<U extends Kind, V extends Kind>(  M: Mappable<U>,  F: Filterable<V>,): <A, X, Y>(  fai: (a: A) => Either<X, Y>,) => <  B = never,  C = never,  D = unknown,  E = unknown,  J = never,  K = never,  L = unknown,  M = unknown,>(  ua: $<U, [$<V, [A, B, C], [D], [E]>, J, K], [L], [M]>,) => Pair<  $<U, [$<V, [Y, B, C], [D], [E]>, J, K], [L], [M]>,  $<U, [$<V, [X, B, C], [D], [E]>, J, K], [L], [M]>> {  const _filterMap = filterMap(M, F);  return (predicate) => {    const first = flow(predicate, getRight);    const second = flow(predicate, getLeft);    return (uva) => [      pipe(uva, _filterMap(first)),      pipe(uva, _filterMap(second)),    ];  };}