onrails
    Preparing search index...
    • Variadic point-free composition — left-to-right.

      const parseUserName = flow(
      (raw: string) => parseConfig(raw),
      map((cfg) => cfg.user),
      flatMap((u) => u.name ? ok(u.name) : err({ kind: "missing" })),
      );

      parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>

      Use pipe from @onrails/result when you have a starting value; use flow when you want to define a reusable composed function.

      Type Parameters

      • A extends readonly unknown[]
      • B

      Parameters

      • ab: (...a: A) => B

      Returns (...a: A) => B

    • Variadic point-free composition — left-to-right.

      const parseUserName = flow(
      (raw: string) => parseConfig(raw),
      map((cfg) => cfg.user),
      flatMap((u) => u.name ? ok(u.name) : err({ kind: "missing" })),
      );

      parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>

      Use pipe from @onrails/result when you have a starting value; use flow when you want to define a reusable composed function.

      Type Parameters

      • A extends readonly unknown[]
      • B
      • C

      Parameters

      • ab: (...a: A) => B
      • bc: (b: B) => C

      Returns (...a: A) => C

    • Variadic point-free composition — left-to-right.

      const parseUserName = flow(
      (raw: string) => parseConfig(raw),
      map((cfg) => cfg.user),
      flatMap((u) => u.name ? ok(u.name) : err({ kind: "missing" })),
      );

      parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>

      Use pipe from @onrails/result when you have a starting value; use flow when you want to define a reusable composed function.

      Type Parameters

      • A extends readonly unknown[]
      • B
      • C
      • D

      Parameters

      • ab: (...a: A) => B
      • bc: (b: B) => C
      • cd: (c: C) => D

      Returns (...a: A) => D

    • Variadic point-free composition — left-to-right.

      const parseUserName = flow(
      (raw: string) => parseConfig(raw),
      map((cfg) => cfg.user),
      flatMap((u) => u.name ? ok(u.name) : err({ kind: "missing" })),
      );

      parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>

      Use pipe from @onrails/result when you have a starting value; use flow when you want to define a reusable composed function.

      Type Parameters

      • A extends readonly unknown[]
      • B
      • C
      • D
      • E

      Parameters

      • ab: (...a: A) => B
      • bc: (b: B) => C
      • cd: (c: C) => D
      • de: (d: D) => E

      Returns (...a: A) => E

    • Variadic point-free composition — left-to-right.

      const parseUserName = flow(
      (raw: string) => parseConfig(raw),
      map((cfg) => cfg.user),
      flatMap((u) => u.name ? ok(u.name) : err({ kind: "missing" })),
      );

      parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>

      Use pipe from @onrails/result when you have a starting value; use flow when you want to define a reusable composed function.

      Type Parameters

      • A extends readonly unknown[]
      • B
      • C
      • D
      • E
      • F

      Parameters

      • ab: (...a: A) => B
      • bc: (b: B) => C
      • cd: (c: C) => D
      • de: (d: D) => E
      • ef: (e: E) => F

      Returns (...a: A) => F

    • Variadic point-free composition — left-to-right.

      const parseUserName = flow(
      (raw: string) => parseConfig(raw),
      map((cfg) => cfg.user),
      flatMap((u) => u.name ? ok(u.name) : err({ kind: "missing" })),
      );

      parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>

      Use pipe from @onrails/result when you have a starting value; use flow when you want to define a reusable composed function.

      Type Parameters

      • A extends readonly unknown[]
      • B
      • C
      • D
      • E
      • F
      • G

      Parameters

      • ab: (...a: A) => B
      • bc: (b: B) => C
      • cd: (c: C) => D
      • de: (d: D) => E
      • ef: (e: E) => F
      • fg: (f: F) => G

      Returns (...a: A) => G

    • Variadic point-free composition — left-to-right.

      const parseUserName = flow(
      (raw: string) => parseConfig(raw),
      map((cfg) => cfg.user),
      flatMap((u) => u.name ? ok(u.name) : err({ kind: "missing" })),
      );

      parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>

      Use pipe from @onrails/result when you have a starting value; use flow when you want to define a reusable composed function.

      Type Parameters

      • A extends readonly unknown[]
      • B
      • C
      • D
      • E
      • F
      • G
      • H

      Parameters

      • ab: (...a: A) => B
      • bc: (b: B) => C
      • cd: (c: C) => D
      • de: (d: D) => E
      • ef: (e: E) => F
      • fg: (f: F) => G
      • gh: (g: G) => H

      Returns (...a: A) => H

    • Variadic point-free composition — left-to-right.

      const parseUserName = flow(
      (raw: string) => parseConfig(raw),
      map((cfg) => cfg.user),
      flatMap((u) => u.name ? ok(u.name) : err({ kind: "missing" })),
      );

      parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>

      Use pipe from @onrails/result when you have a starting value; use flow when you want to define a reusable composed function.

      Type Parameters

      • A extends readonly unknown[]
      • B
      • C
      • D
      • E
      • F
      • G
      • H
      • I

      Parameters

      • ab: (...a: A) => B
      • bc: (b: B) => C
      • cd: (c: C) => D
      • de: (d: D) => E
      • ef: (e: E) => F
      • fg: (f: F) => G
      • gh: (g: G) => H
      • hi: (h: H) => I

      Returns (...a: A) => I