fp-pack 0.1.0 → 0.3.0

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

@@ -1,13 +1,17 @@
 import SideEffect from './sideEffect';
 import pipe from './pipe';
 import pipeSideEffect from './pipeSideEffect';
+import pipeSideEffectStrict from './pipeSideEffectStrict';
 import pipeAsync from '../async/pipeAsync';
 import pipeAsyncSideEffect from '../async/pipeAsyncSideEffect';
+import pipeAsyncSideEffectStrict from '../async/pipeAsyncSideEffectStrict';
 
 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 EffectUnion<T> = Extract<T, SideEffect<any>> extends SideEffect<infer E> ? E : never;
+type ValueUnion<T> = Exclude<T, SideEffect<any>>;
 
 export const sideEffectInput = SideEffect.of(() => 0);
 
@@ -20,6 +24,18 @@ export const purePipe = pipe(
 type PurePipeExpected = (input: number) => string;
 export type PipePureIsStrict = Expect<Equal<typeof purePipe, PurePipeExpected>>;
 
+export const purePipeSix = pipe(
+  (value: number) => value + 1,
+  (value) => value * 2,
+  (value) => `${value}`,
+  (value) => value.length,
+  (value) => value + 1,
+  (value) => `n:${value}`
+);
+
+type PurePipeSixExpected = (input: number) => string;
+export type PipePureSixIsStrict = Expect<Equal<typeof purePipeSix, PurePipeSixExpected>>;
+
 export const pipeWithSideEffectInput = pipeSideEffect(
   (value: number) => value + 1,
   (value) => value * 2,
@@ -31,6 +47,18 @@ export const pipeWithSideEffectValue = pipeWithSideEffectInput(sideEffectInput);
 type PipeExpected = (input: number | SideEffect<any>) => string | SideEffect<any>;
 export type PipeAcceptsSideEffectInput = Expect<Equal<typeof pipeWithSideEffectInput, PipeExpected>>;
 
+export const pipeSideEffectSix = pipeSideEffect(
+  (value: number) => value + 1,
+  (value) => value * 2,
+  (value) => value + 3,
+  (value) => value - 1,
+  (value) => value * 2,
+  (value) => `n:${value}`
+);
+
+type PipeSideEffectSixExpected = (input: number | SideEffect<any>) => string | SideEffect<any>;
+export type PipeSideEffectSixIsStrict = Expect<Equal<typeof pipeSideEffectSix, PipeSideEffectSixExpected>>;
+
 export const purePipeAsync = pipeAsync(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -40,6 +68,18 @@ export const purePipeAsync = pipeAsync(
 type PurePipeAsyncExpected = (input: number) => Promise<string>;
 export type PipeAsyncPureIsStrict = Expect<Equal<typeof purePipeAsync, PurePipeAsyncExpected>>;
 
+export const purePipeAsyncSix = pipeAsync(
+  (value: number) => value + 1,
+  async (value) => value * 2,
+  (value) => `${value}`,
+  async (value) => value.length,
+  (value) => value + 3,
+  async (value) => `n:${value}`
+);
+
+type PurePipeAsyncSixExpected = (input: number) => Promise<string>;
+export type PipeAsyncPureSixIsStrict = Expect<Equal<typeof purePipeAsyncSix, PurePipeAsyncSixExpected>>;
+
 export const pipeAsyncWithSideEffectInput = pipeAsyncSideEffect(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -52,3 +92,105 @@ type PipeAsyncExpected = (input: number | SideEffect<any>) => Promise<string | S
 export type PipeAsyncAcceptsSideEffectInput = Expect<
   Equal<typeof pipeAsyncWithSideEffectInput, PipeAsyncExpected>
 >;
+
+export const pipeAsyncSideEffectSix = pipeAsyncSideEffect(
+  (value: number) => value + 1,
+  async (value) => value * 2,
+  (value) => value + 3,
+  async (value) => value - 1,
+  (value) => value * 2,
+  async (value) => `n:${value}`
+);
+
+type PipeAsyncSideEffectSixExpected = (input: number | SideEffect<any>) => Promise<string | SideEffect<any>>;
+export type PipeAsyncSideEffectSixIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectSix, PipeAsyncSideEffectSixExpected>
+>;
+
+export const strictPipeSideEffect = pipeSideEffectStrict(
+  (value: number) => value + 1,
+  (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => (value > 2 ? value : SideEffect.of(() => 0 as const))
+);
+
+export const strictPipeSideEffectResult = strictPipeSideEffect(1);
+
+type StrictSideEffectEffects = EffectUnion<typeof strictPipeSideEffectResult>;
+type StrictSideEffectEffectsExpected = 'LOW' | 0;
+export type PipeSideEffectStrictEffects = Expect<Equal<StrictSideEffectEffects, StrictSideEffectEffectsExpected>>;
+
+type StrictSideEffectValue = ValueUnion<typeof strictPipeSideEffectResult>;
+type StrictSideEffectValueExpected = number;
+export type PipeSideEffectStrictValue = Expect<Equal<StrictSideEffectValue, StrictSideEffectValueExpected>>;
+
+export const strictPipeSideEffectInput = strictPipeSideEffect(SideEffect.of(() => 'INPUT' as const));
+
+type StrictSideEffectInputEffects = EffectUnion<typeof strictPipeSideEffectInput>;
+type StrictSideEffectInputEffectsExpected = 'LOW' | 0 | 'INPUT';
+export type PipeSideEffectStrictInputEffects = Expect<
+  Equal<StrictSideEffectInputEffects, StrictSideEffectInputEffectsExpected>
+>;
+
+export const strictPipeSideEffectSix = pipeSideEffectStrict(
+  (value: number) => value + 1,
+  (value) => (value > 2 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => value + 1,
+  (value) => (value > 10 ? value : SideEffect.of(() => 'SMALL' as const)),
+  (value) => value * 2,
+  (value) => (value > 40 ? value : SideEffect.of(() => 0 as const))
+);
+
+export const strictPipeSideEffectSixResult = strictPipeSideEffectSix(1);
+
+type StrictSixEffects = EffectUnion<typeof strictPipeSideEffectSixResult>;
+type StrictSixEffectsExpected = 'LOW' | 'SMALL' | 0;
+export type PipeSideEffectStrictSixEffects = Expect<Equal<StrictSixEffects, StrictSixEffectsExpected>>;
+
+type StrictSixValue = ValueUnion<typeof strictPipeSideEffectSixResult>;
+type StrictSixValueExpected = number;
+export type PipeSideEffectStrictSixValue = Expect<Equal<StrictSixValue, StrictSixValueExpected>>;
+
+export const strictPipeAsyncSideEffect = pipeAsyncSideEffectStrict(
+  (value: number) => value + 1,
+  async (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => (value > 2 ? value : SideEffect.of(() => 0 as const))
+);
+
+export const strictPipeAsyncSideEffectResult = strictPipeAsyncSideEffect(1);
+
+type StrictPipeAsyncResolved = Awaited<typeof strictPipeAsyncSideEffectResult>;
+type StrictPipeAsyncEffects = EffectUnion<StrictPipeAsyncResolved>;
+type StrictPipeAsyncEffectsExpected = 'LOW' | 0;
+export type PipeAsyncSideEffectStrictEffects = Expect<
+  Equal<StrictPipeAsyncEffects, StrictPipeAsyncEffectsExpected>
+>;
+
+type StrictPipeAsyncValue = ValueUnion<StrictPipeAsyncResolved>;
+type StrictPipeAsyncValueExpected = number;
+export type PipeAsyncSideEffectStrictValue = Expect<
+  Equal<StrictPipeAsyncValue, StrictPipeAsyncValueExpected>
+>;
+
+export const strictPipeAsyncSideEffectSix = pipeAsyncSideEffectStrict(
+  (value: number) => value + 1,
+  async (value) => (value > 2 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => value + 1,
+  async (value) => (value > 10 ? value : SideEffect.of(() => 'SMALL' as const)),
+  (value) => value * 2,
+  async (value) => (value > 40 ? value : SideEffect.of(() => 0 as const))
+);
+
+export const strictPipeAsyncSideEffectSixResult = strictPipeAsyncSideEffectSix(1);
+
+type StrictAsyncSixResolved = Awaited<typeof strictPipeAsyncSideEffectSixResult>;
+type StrictAsyncSixEffects = EffectUnion<StrictAsyncSixResolved>;
+type StrictAsyncSixEffectsExpected = 'LOW' | 'SMALL' | 0;
+export type PipeAsyncSideEffectStrictSixEffects = Expect<
+  Equal<StrictAsyncSixEffects, StrictAsyncSixEffectsExpected>
+>;
+
+type StrictAsyncSixValue = ValueUnion<StrictAsyncSixResolved>;
+type StrictAsyncSixValueExpected = number;
+export type PipeAsyncSideEffectStrictSixValue = Expect<
+  Equal<StrictAsyncSixValue, StrictAsyncSixValueExpected>
+>;

package/src/implement/composition/pipeSideEffect.test.ts

@@ -20,4 +20,12 @@ describe('pipeSideEffect', () => {
 
     expect(fn(effect)).toBe(effect);
   });
+
+  it('supports zero-arity starts', () => {
+    const start = () => 3;
+    const addOne = (n: number) => n + 1;
+    const fn = pipeSideEffect(start, addOne);
+
+    expect(fn()).toBe(4);
+  });
 });

package/src/implement/composition/pipeSideEffect.ts

@@ -3,6 +3,7 @@ import SideEffect, { isSideEffect } from './sideEffect';
 type MaybeSideEffect<T> = T | SideEffect<any>;
 type NonSideEffect<T> = Exclude<T, SideEffect<any>>;
 type UnaryFn<A, R> = (a: A) => MaybeSideEffect<R>;
+type ZeroFn<R> = () => MaybeSideEffect<R>;
 type PipeInput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<infer A, any>, ...UnaryFn<any, any>[]]
   ? A
   : never;
@@ -18,6 +19,30 @@ type PipeSideEffect<Fns extends UnaryFn<any, any>[]> = (
   input: PipeInput<Fns> | SideEffect<any>
 ) => Resolve<PipeOutput<Fns>>;
 
+function pipeSideEffect<R>(ab: ZeroFn<R>): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, R>(ab: ZeroFn<B>, bc: UnaryFn<B, R>): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, C, R>(ab: ZeroFn<B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, R>): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, C, D, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, R>
+): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, C, D, E, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, R>
+): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, C, D, E, F, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, R>
+): () => MaybeSideEffect<R>;
 function pipeSideEffect<A, R>(ab: UnaryFn<A, R>): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
 function pipeSideEffect<A, B, R>(
   ab: UnaryFn<A, B>,
@@ -41,6 +66,14 @@ function pipeSideEffect<A, B, C, D, E, R>(
   de: UnaryFn<D, E>,
   ef: UnaryFn<E, R>
 ): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<A, B, C, D, E, F, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, R>
+): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
 
 function pipeSideEffect<Fns extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): PipeSideEffect<Fns>;
 function pipeSideEffect(...funcs: Array<UnaryFn<any, any>>): (input: any) => any;

package/src/implement/composition/pipeSideEffectStrict.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import pipeSideEffectStrict from './pipeSideEffectStrict';
+import SideEffect from './sideEffect';
+
+describe('pipeSideEffectStrict', () => {
+  it('short-circuits when SideEffect is returned', () => {
+    const effect = new SideEffect(() => 'effect');
+    const stop = (_value: number) => effect;
+    const after = (_value: number) => _value + 1;
+
+    const fn = pipeSideEffectStrict((n: number) => n + 1, stop, after);
+    const result = fn(1);
+
+    expect(result).toBe(effect);
+  });
+
+  it('returns SideEffect inputs without executing the pipeline', () => {
+    const effect = new SideEffect(() => 'effect');
+    const fn = pipeSideEffectStrict((n: number) => n + 1);
+
+    expect(fn(effect)).toBe(effect);
+  });
+});

package/src/implement/composition/pipeSideEffectStrict.ts

@@ -0,0 +1,164 @@
+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<B, C, D, E, F, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, R>
+): PipeSideEffectStrict<[
+  ZeroFn<B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, 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<A, B, C, D, E, F, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, R>
+): PipeSideEffectStrict<[
+  UnaryFn<A, B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, 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;