fp-pack 0.5.0 → 0.7.0

package/src/implement/composition/compose.type-test.ts

@@ -0,0 +1,109 @@
+import compose from './compose';
+import from from './from';
+
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
+  ? true
+  : false;
+type Expect<T extends true> = T;
+
+export const pureCompose = compose(
+  (value: string) => `n:${value}`,
+  (value: number) => `${value}`,
+  (value: number) => value * 2,
+  (value: number) => value + 1
+);
+
+type PureComposeExpected = (input: number) => string;
+export type ComposePureIsStrict = Expect<Equal<typeof pureCompose, PureComposeExpected>>;
+
+export const pureComposeSix = compose(
+  (value: number) => `n:${value}`,
+  (value: number) => value + 1,
+  (value: string) => value.length,
+  (value: number) => `${value}`,
+  (value: number) => value * 2,
+  (value: number) => value + 1
+);
+
+type PureComposeSixExpected = (input: number) => string;
+export type ComposePureSixIsStrict = Expect<Equal<typeof pureComposeSix, PureComposeSixExpected>>;
+
+export const pureComposeTen = compose(
+  (value: string) => `n:${value}`,
+  (value: string) => value.padStart(4, '0'),
+  (value: number) => `${value}`,
+  (value: number) => value + 1,
+  (value: string) => value.length,
+  (value: string) => value.padStart(3, '0'),
+  (value: number) => `${value}`,
+  (value: number) => value * 2,
+  (value: number) => value + 1,
+  (value: number) => value + 1
+);
+
+type PureComposeTenExpected = (input: number) => string;
+export type ComposePureTenIsStrict = Expect<Equal<typeof pureComposeTen, PureComposeTenExpected>>;
+
+export const composeZero = compose(
+  (value: number) => value + 1,
+  (value: number) => value * 2,
+  () => 1
+);
+
+type ComposeZeroExpected = () => number;
+export type ComposeZeroIsStrict = Expect<Equal<typeof composeZero, ComposeZeroExpected>>;
+
+export const composeZeroValue = composeZero();
+
+type ComposeZeroValueExpected = number;
+export type ComposeZeroValueIsStrict = Expect<Equal<typeof composeZeroValue, ComposeZeroValueExpected>>;
+
+export const composeFromNoInput = compose(from(1));
+
+type ComposeFromNoInputExpected = (input?: unknown) => number;
+export type ComposeFromNoInputIsStrict = Expect<Equal<typeof composeFromNoInput, ComposeFromNoInputExpected>>;
+
+export const composeFromNoInputValue = composeFromNoInput();
+
+type ComposeFromNoInputValueExpected = number;
+export type ComposeFromNoInputValueIsStrict = Expect<
+  Equal<typeof composeFromNoInputValue, ComposeFromNoInputValueExpected>
+>;
+
+export const composeFromNoInputValueWithArg = composeFromNoInput('input');
+
+type ComposeFromNoInputValueWithArgExpected = number;
+export type ComposeFromNoInputValueWithArgIsStrict = Expect<
+  Equal<typeof composeFromNoInputValueWithArg, ComposeFromNoInputValueWithArgExpected>
+>;
+
+export const composeFromTen = compose(
+  (value: string) => `n:${value}`,
+  (value: string) => value.padStart(4, '0'),
+  (value: number) => `${value}`,
+  (value: number) => value + 1,
+  (value: string) => value.length,
+  (value: string) => value.padStart(3, '0'),
+  (value: number) => `${value}`,
+  (value: number) => value * 2,
+  (value: number) => value + 1,
+  from(1)
+);
+
+export const composeFromTenValue = composeFromTen('input');
+
+type ComposeFromTenValueExpected = string;
+export type ComposeFromTenValueIsStrict = Expect<Equal<typeof composeFromTenValue, ComposeFromTenValueExpected>>;
+
+export const composeFromTenValueNoInput = composeFromTen();
+
+type ComposeFromTenValueNoInputExpected = string;
+export type ComposeFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof composeFromTenValueNoInput, ComposeFromTenValueNoInputExpected>
+>;
+
+// Negative cases: input required when not using from/zero-arity.
+// @ts-expect-error input required for unary compose
+pureCompose();
+// @ts-expect-error input required for direct compose call
+compose((value: number) => value + 1)();

package/src/implement/composition/compose.util.type-test.ts

@@ -0,0 +1,128 @@
+import compose from './compose';
+import filter from '../array/filter';
+import flattenDeep from '../array/flattenDeep';
+import map from '../array/map';
+import sum from '../math/sum';
+import gt from '../equality/gt';
+import when from '../control/when';
+import ifElse from '../control/ifElse';
+import log from '../debug/log';
+import tap from './tap';
+import prop from '../object/prop';
+import mergeAll from '../object/mergeAll';
+import getOrElse from '../nullable/getOrElse';
+import mapMaybe from '../nullable/mapMaybe';
+import join from '../string/join';
+import trim from '../string/trim';
+import toUpper from '../string/toUpper';
+import streamFilter from '../../stream/filter';
+import streamMap from '../../stream/map';
+import streamRange from '../../stream/range';
+import streamReduce from '../../stream/reduce';
+import streamToArray from '../../stream/toArray';
+
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
+  ? true
+  : false;
+type Expect<T extends true> = T;
+
+type User = {
+  name?: string;
+};
+
+type TagOwner = {
+  tags?: Array<string | null>;
+};
+
+type Config = {
+  value?: number;
+};
+
+const getName = prop('name') as (user: User) => string | undefined;
+const getTags = prop('tags') as (owner: TagOwner) => Array<string | null> | undefined;
+const mergeConfig = mergeAll as (configs: Config[]) => Config;
+const getValue = prop('value') as (config: Config) => number | undefined;
+const streamMapNumber = streamMap((value: number) => value + 1) as (iterable: Iterable<number>) => IterableIterator<number>;
+const streamFilterNumber = streamFilter((value: number) => value > 1) as (
+  iterable: Iterable<number>
+) => IterableIterator<number>;
+const streamReduceNumber = streamReduce((acc: number, value: number) => acc + value, 0) as (
+  iterable: Iterable<number>
+) => number;
+const streamMapAsyncNumber = streamMap(async (value: number) => value + 1) as (
+  iterable: Iterable<number>
+) => IterableIterator<Promise<number>>;
+const whenPositive = when<number>(gt(0), (value) => value + 1);
+
+export const composeArrayControlString = compose(
+  log('total'),
+  toUpper,
+  trim,
+  (value: number) => `${value}`,
+  when(gt(10), (value) => value + 1),
+  sum,
+  map((value: number) => value * 2),
+  filter(gt(1)),
+  flattenDeep<number>
+);
+
+type ComposeArrayControlStringExpected = (input: any[]) => string;
+export type ComposeArrayControlStringIsStrict = Expect<
+  Equal<typeof composeArrayControlString, ComposeArrayControlStringExpected>
+>;
+
+export const composeObjectNullableControl = compose(
+  tap((value: string) => value.length),
+  ifElse(
+    (value: string) => value.length > 0,
+    toUpper,
+    () => 'UNKNOWN'
+  ),
+  getOrElse(''),
+  getName
+);
+
+type ComposeObjectNullableControlExpected = (input: User) => string;
+export type ComposeObjectNullableControlIsStrict = Expect<
+  Equal<typeof composeObjectNullableControl, ComposeObjectNullableControlExpected>
+>;
+
+export const composeTags = compose(
+  join('|'),
+  map((tag: string) => tag.toUpperCase()),
+  mapMaybe((tag: string | null) => (tag ? tag.trim() : null)),
+  getOrElse<Array<string | null>>([]),
+  getTags
+);
+
+type ComposeTagsExpected = (input: TagOwner) => string;
+export type ComposeTagsIsStrict = Expect<Equal<typeof composeTags, ComposeTagsExpected>>;
+
+export const composeConfigValue = compose(
+  whenPositive,
+  getOrElse(0),
+  getValue,
+  mergeConfig
+);
+
+type ComposeConfigValueExpected = (input: Config[]) => number;
+export type ComposeConfigValueIsStrict = Expect<Equal<typeof composeConfigValue, ComposeConfigValueExpected>>;
+
+export const composeStreamSync = compose(
+  streamReduceNumber,
+  streamFilterNumber,
+  streamMapNumber,
+  (end: number) => streamRange(0, end)
+);
+
+type ComposeStreamSyncExpected = (input: number) => number;
+export type ComposeStreamSyncIsStrict = Expect<Equal<typeof composeStreamSync, ComposeStreamSyncExpected>>;
+
+export const composeStreamToArray = compose(
+  streamToArray,
+  streamMapAsyncNumber,
+  (end: number) => streamRange(0, end)
+);
+
+type ComposeStreamToArrayExpected = (input: number) => Promise<number[]>;
+export type ComposeStreamToArrayIsStrict = Expect<Equal<typeof composeStreamToArray, ComposeStreamToArrayExpected>>;

package/src/implement/composition/curry.ts

@@ -3,14 +3,14 @@
  * Supports functions with 2-5 parameters and keeps data-last call order.
  */
 
-type Curry2<Fn> = Fn extends (a: infer A, b: infer B) => infer R
+export type Curry2<Fn> = Fn extends (a: infer A, b: infer B) => infer R
   ? {
       (...args: [A]): (b: B) => R;
       (...args: [A, B]): R;
     }
   : never;
 
-type Curry3<Fn> = Fn extends (a: infer A, b: infer B, c: infer C) => infer R
+export type Curry3<Fn> = Fn extends (a: infer A, b: infer B, c: infer C) => infer R
   ? {
       (...args: [A]): (b: B) => (c: C) => R;
       (...args: [A, B]): (c: C) => R;
@@ -18,7 +18,7 @@ type Curry3<Fn> = Fn extends (a: infer A, b: infer B, c: infer C) => infer R
     }
   : never;
 
-type Curry4<Fn> = Fn extends (a: infer A, b: infer B, c: infer C, d: infer D) => infer R
+export type Curry4<Fn> = Fn extends (a: infer A, b: infer B, c: infer C, d: infer D) => infer R
   ? {
       (...args: [A]): (b: B) => (c: C) => (d: D) => R;
       (...args: [A, B]): (c: C) => (d: D) => R;
@@ -27,7 +27,7 @@ type Curry4<Fn> = Fn extends (a: infer A, b: infer B, c: infer C, d: infer D) =>
     }
   : never;
 
-type Curry5<Fn> = Fn extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E) => infer R
+export type Curry5<Fn> = Fn extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E) => infer R
   ? {
       (...args: [A]): (b: B) => (c: C) => (d: D) => (e: E) => R;
       (...args: [A, B]): (c: C) => (d: D) => (e: E) => R;
@@ -53,7 +53,7 @@ type CurryByArity<Fn extends (...args: any[]) => any> = Parameters<Fn>['length']
         ? Curry5<Fn>
         : CurryVariadic<Fn>;
 
-type Curried<Fn extends (...args: any[]) => any> = CurryByArity<Fn>;
+export type Curried<Fn extends (...args: any[]) => any> = CurryByArity<Fn>;
 
 function curry<Fn extends (...args: any[]) => any>(fn: Fn): Curried<Fn>;
 

package/src/implement/composition/index.ts

@@ -3,15 +3,19 @@ export { default as pipeSideEffect } from './pipeSideEffect';
 export { default as pipeSideEffectStrict } from './pipeSideEffectStrict';
 export { default as compose } from './compose';
 export { default as curry } from './curry';
+export type { Curried, Curry2, Curry3, Curry4, Curry5 } from './curry';
 export { default as partial } from './partial';
 export { default as flip } from './flip';
 export { default as complement } from './complement';
 export { default as identity } from './identity';
 export { default as constant } from './constant';
 export { default as from } from './from';
+export type { FromFn } from './from';
 export { default as tap } from './tap';
+export { default as tap0 } from './tap0';
 export { default as once } from './once';
 export { default as memoize } from './memoize';
 export { default as SideEffect } from './sideEffect';
 export { SideEffect as SideEffectClass } from './sideEffect';
 export { isSideEffect, matchSideEffect, runPipeResult } from './sideEffect';
+export type { MatchHandlers } from './sideEffect';

package/src/implement/composition/pipe.ts

@@ -1,3 +1,5 @@
+import type { FromFn } from './from';
+
 type UnaryFn<A, R> = (a: A) => R;
 type ZeroFn<R> = () => R;
 type PipeInput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<infer A, any>, ...UnaryFn<any, any>[]]
@@ -11,6 +13,7 @@ type PipeOutput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<any, inf
       : never
     : never;
 type Pipe<Fns extends UnaryFn<any, any>[]> = (input: PipeInput<Fns>) => PipeOutput<Fns>;
+type PipeFrom<Fns extends [FromFn<any>, ...UnaryFn<any, any>[]]> = (input?: PipeInput<Fns>) => PipeOutput<Fns>;
 
 function pipe<R>(ab: ZeroFn<R>): () => R;
 function pipe<B, R>(ab: ZeroFn<B>, bc: UnaryFn<B, R>): () => R;
@@ -73,6 +76,7 @@ function pipe<B, C, D, E, F, G, H, I, J, R>(
   ij: UnaryFn<I, J>,
   jk: UnaryFn<J, R>
 ): () => R;
+function pipe<Fns extends [FromFn<any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): PipeFrom<Fns>;
 function pipe<A, R>(ab: UnaryFn<A, R>): (a: A) => R;
 function pipe<A, B, R>(ab: UnaryFn<A, B>, bc: UnaryFn<B, R>): (a: A) => R;
 function pipe<A, B, C, R>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, R>): (a: A) => R;