fp-pack 0.1.0 → 0.2.0

package/src/implement/composition/pipeSideEffectStrict.ts

@@ -0,0 +1,134 @@
+import SideEffect, { isSideEffect } from './sideEffect';
+
+type AnyFn = (...args: any[]) => any;
+type MaybeSideEffect<T, E> = T | SideEffect<E>;
+type NonSideEffect<T> = Exclude<T, SideEffect<any>>;
+type UnaryFn<A, R> = (a: A) => R;
+type ZeroFn<R> = () => R;
+
+type EffectOfReturn<R> = R extends SideEffect<infer E> ? E : never;
+type EffectOfFn<F> = F extends (...args: any[]) => infer R ? EffectOfReturn<R> : never;
+type EffectsOf<Fns extends AnyFn[]> = EffectOfFn<Fns[number]>;
+
+type PipeValueOutputUnary<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<any, infer R>]
+  ? NonSideEffect<R>
+  : Fns extends [UnaryFn<any, infer R>, ...infer Rest]
+    ? Rest extends [UnaryFn<NonSideEffect<R>, any>, ...UnaryFn<any, any>[]]
+      ? PipeValueOutputUnary<Rest>
+      : never
+    : never;
+
+type PipeValueOutputStrict<Fns extends [AnyFn, ...AnyFn[]]> =
+  Fns extends [ZeroFn<infer R>]
+    ? NonSideEffect<R>
+    : Fns extends [ZeroFn<infer R>, ...infer Rest]
+      ? Rest extends [UnaryFn<NonSideEffect<R>, any>, ...UnaryFn<any, any>[]]
+        ? PipeValueOutputUnary<Rest>
+        : never
+      : Fns extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]
+        ? PipeValueOutputUnary<Fns>
+        : never;
+
+type PipeInputStrict<Fns extends [AnyFn, ...AnyFn[]]> = Fns extends [ZeroFn<any>, ...AnyFn[]]
+  ? never
+  : Fns extends [UnaryFn<infer A, any>, ...AnyFn[]]
+    ? A
+    : never;
+
+type Resolve<T> = T extends infer R ? R : never;
+
+type PipeSideEffectStrictUnary<Fns extends [AnyFn, ...AnyFn[]]> = {
+  (input: PipeInputStrict<Fns>): Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns>>>;
+  <EIn>(
+    input: PipeInputStrict<Fns> | SideEffect<EIn>
+  ): Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns> | EIn>>;
+};
+
+type PipeSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]> = Fns extends [ZeroFn<any>, ...AnyFn[]]
+  ? () => Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns>>>
+  : PipeSideEffectStrictUnary<Fns>;
+
+function pipeSideEffectStrict<R>(ab: ZeroFn<R>): PipeSideEffectStrict<[ZeroFn<R>]>;
+function pipeSideEffectStrict<B, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, R>
+): PipeSideEffectStrict<[ZeroFn<B>, UnaryFn<NonSideEffect<B>, R>]>;
+function pipeSideEffectStrict<B, C, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, R>
+): PipeSideEffectStrict<[ZeroFn<B>, UnaryFn<NonSideEffect<B>, C>, UnaryFn<NonSideEffect<C>, R>]>;
+function pipeSideEffectStrict<B, C, D, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, R>
+): PipeSideEffectStrict<[
+  ZeroFn<B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, R>
+]>;
+function pipeSideEffectStrict<B, C, D, E, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, R>
+): PipeSideEffectStrict<[
+  ZeroFn<B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, R>
+]>;
+function pipeSideEffectStrict<A, R>(ab: UnaryFn<A, R>): PipeSideEffectStrict<[UnaryFn<A, R>]>;
+function pipeSideEffectStrict<A, B, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, R>
+): PipeSideEffectStrict<[UnaryFn<A, B>, UnaryFn<NonSideEffect<B>, R>]>;
+function pipeSideEffectStrict<A, B, C, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, R>
+): PipeSideEffectStrict<[UnaryFn<A, B>, UnaryFn<NonSideEffect<B>, C>, UnaryFn<NonSideEffect<C>, R>]>;
+function pipeSideEffectStrict<A, B, C, D, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, R>
+): PipeSideEffectStrict<[
+  UnaryFn<A, B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, R>
+]>;
+function pipeSideEffectStrict<A, B, C, D, E, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, R>
+): PipeSideEffectStrict<[
+  UnaryFn<A, B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, R>
+]>;
+
+function pipeSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]>(...funcs: Fns): PipeSideEffectStrict<Fns>;
+function pipeSideEffectStrict(...funcs: Array<(input: any) => any>) {
+  return (init?: any) => {
+    let acc = init;
+    for (const fn of funcs) {
+      if (isSideEffect(acc)) {
+        return acc;
+      }
+      acc = fn(acc);
+    }
+    return acc;
+  };
+}
+
+export default pipeSideEffectStrict;

package/src/implement/control/curried.test.ts

@@ -68,4 +68,22 @@ describe('control (curried)', () => {
     expect(applyWhen(5)).toBe(5);
     expect(applyWhen(20)).toBe(21);
   });
+
+  it('infers types across curried stages', () => {
+    const predicate = (value: number) => value > 0;
+    const onTrue = (value: number) => value * 2;
+    const onFalse = (value: number) => value - 2;
+
+    const choose = ifElse(predicate)(onTrue)(onFalse);
+    expect(choose(3)).toBe(6);
+    expect(choose(-1)).toBe(-3);
+
+    const applyWhen = when(predicate)((value) => value + 1);
+    const applyUnless = unless(predicate)((value) => value + 1);
+
+    expect(applyWhen(2)).toBe(3);
+    expect(applyWhen(-2)).toBe(-2);
+    expect(applyUnless(2)).toBe(2);
+    expect(applyUnless(-2)).toBe(-1);
+  });
 });

package/src/implement/control/ifElse.ts

@@ -1,22 +1,24 @@
 import curry from '../composition/curry';
 
+type NoInfer<T> = [T][T extends any ? 0 : never];
+
 type IfElse = {
   <T, RTrue, RFalse>(
     ...args: [predicate: (value: T) => boolean]
   ): (onTrue: (value: T) => RTrue) => (onFalse: (value: T) => RFalse) => (value: T) => RTrue | RFalse;
   <T, RTrue, RFalse>(
-    ...args: [predicate: (value: T) => boolean, onTrue: (value: T) => RTrue]
+    ...args: [predicate: (value: NoInfer<T>) => boolean, onTrue: (value: T) => RTrue]
   ): (onFalse: (value: T) => RFalse) => (value: T) => RTrue | RFalse;
   <T, RTrue, RFalse>(
     ...args: [
-      predicate: (value: T) => boolean,
+      predicate: (value: NoInfer<T>) => boolean,
       onTrue: (value: T) => RTrue,
       onFalse: (value: T) => RFalse
     ]
   ): (value: T) => RTrue | RFalse;
   <T, RTrue, RFalse>(
     ...args: [
-      predicate: (value: T) => boolean,
+      predicate: (value: NoInfer<T>) => boolean,
       onTrue: (value: T) => RTrue,
       onFalse: (value: T) => RFalse,
       value: T

package/src/implement/control/unless.ts

@@ -1,17 +1,35 @@
 import curry from '../composition/curry';
 
+type NoInfer<T> = [T][T extends any ? 0 : never];
 type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
 
 type Unless = {
   <T>(...args: [predicate: (value: Widen<T>) => boolean]): (
     fn: (value: Widen<T>) => Widen<T>
   ) => (value: Widen<T>) => Widen<T>;
+  <T, R>(...args: [predicate: (value: Widen<T>) => boolean]): (
+    fn: (value: Widen<T>) => R
+  ) => (value: Widen<T>) => Widen<T> | R;
   <T>(
-    ...args: [predicate: (value: Widen<T>) => boolean, fn: (value: Widen<T>) => Widen<T>]
+    ...args: [predicate: (value: NoInfer<Widen<T>>) => boolean, fn: (value: Widen<T>) => Widen<T>]
   ): (value: Widen<T>) => Widen<T>;
+  <T, R>(
+    ...args: [predicate: (value: NoInfer<Widen<T>>) => boolean, fn: (value: Widen<T>) => R]
+  ): (value: Widen<T>) => Widen<T> | R;
   <T>(
-    ...args: [predicate: (value: Widen<T>) => boolean, fn: (value: Widen<T>) => Widen<T>, value: Widen<T>]
+    ...args: [
+      predicate: (value: NoInfer<Widen<T>>) => boolean,
+      fn: (value: Widen<T>) => Widen<T>,
+      value: Widen<T>
+    ]
   ): Widen<T>;
+  <T, R>(
+    ...args: [
+      predicate: (value: NoInfer<Widen<T>>) => boolean,
+      fn: (value: Widen<T>) => R,
+      value: Widen<T>
+    ]
+  ): Widen<T> | R;
 };
 
 /**

package/src/implement/control/when.ts

@@ -1,17 +1,35 @@
 import curry from '../composition/curry';
 
+type NoInfer<T> = [T][T extends any ? 0 : never];
 type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
 
 type When = {
   <T>(...args: [predicate: (value: Widen<T>) => boolean]): (
     fn: (value: Widen<T>) => Widen<T>
   ) => (value: Widen<T>) => Widen<T>;
+  <T, R>(...args: [predicate: (value: Widen<T>) => boolean]): (
+    fn: (value: Widen<T>) => R
+  ) => (value: Widen<T>) => Widen<T> | R;
   <T>(
-    ...args: [predicate: (value: Widen<T>) => boolean, fn: (value: Widen<T>) => Widen<T>]
+    ...args: [predicate: (value: NoInfer<Widen<T>>) => boolean, fn: (value: Widen<T>) => Widen<T>]
   ): (value: Widen<T>) => Widen<T>;
+  <T, R>(
+    ...args: [predicate: (value: NoInfer<Widen<T>>) => boolean, fn: (value: Widen<T>) => R]
+  ): (value: Widen<T>) => Widen<T> | R;
   <T>(
-    ...args: [predicate: (value: Widen<T>) => boolean, fn: (value: Widen<T>) => Widen<T>, value: Widen<T>]
+    ...args: [
+      predicate: (value: NoInfer<Widen<T>>) => boolean,
+      fn: (value: Widen<T>) => Widen<T>,
+      value: Widen<T>
+    ]
   ): Widen<T>;
+  <T, R>(
+    ...args: [
+      predicate: (value: NoInfer<Widen<T>>) => boolean,
+      fn: (value: Widen<T>) => R,
+      value: Widen<T>
+    ]
+  ): Widen<T> | R;
 };
 
 /**

package/src/implement/object/index.ts

@@ -1,4 +1,5 @@
 export { default as prop } from './prop';
+export { default as propStrict } from './propStrict';
 export { default as propOr } from './propOr';
 export { default as path } from './path';
 export { default as pathOr } from './pathOr';

package/src/implement/object/propStrict.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import propStrict from './propStrict';
+
+describe('propStrict', () => {
+  it('gets a property', () => {
+    const user = { id: 1, name: 'A' };
+    expect(propStrict('name', user)).toBe('A');
+  });
+
+  it('supports currying', () => {
+    const user = { name: 'A' };
+    const getName = propStrict('name');
+    expect(getName(user)).toBe('A');
+  });
+
+  it('throws when property is missing', () => {
+    type User = { name: string; age?: number };
+    const user: User = { name: 'A' };
+    expect(() => propStrict('age', user)).toThrow(/propStrict/);
+  });
+
+  it('throws when value is null or undefined', () => {
+    const nullUser: { name: string | null } = { name: null };
+    expect(() => propStrict('name', nullUser)).toThrow(/propStrict/);
+
+    const undefinedUser: { name: string | undefined } = { name: undefined };
+    expect(() => propStrict('name', undefinedUser)).toThrow(/propStrict/);
+  });
+});

package/src/implement/object/propStrict.ts

@@ -0,0 +1,20 @@
+import curry from '../composition/curry';
+
+type PropStrict = {
+  <K extends PropertyKey>(...args: [key: K]): <T extends Record<K, unknown>>(obj: T) => NonNullable<T[K]>;
+  <T, K extends keyof T>(...args: [key: K, obj: T]): NonNullable<T[K]>;
+};
+
+/**
+ * propStrict - strict property access (throws on null/undefined)
+ */
+function propStrict<T, K extends keyof T = keyof T>(key: K, obj: T): NonNullable<T[K]> {
+  const value = obj?.[key];
+  if (value == null) {
+    throw new Error(`propStrict: "${String(key)}" is null or undefined`);
+  }
+  return value as NonNullable<T[K]>;
+}
+
+const curriedPropStrict = curry(propStrict) as unknown as PropStrict;
+export default curriedPropStrict;