Pipe Basics

The pipe function is the heart of @praha/byethrow. It allows you to chain multiple operations together in a readable, left-to-right manner.

What is `pipe`?

pipe takes an initial value and passes it through a series of functions, where each function receives the output of the previous one:

import { import ResultResult } from '@praha/byethrow';

const const result: stringresult = import ResultResult.const pipe: <number, number, number, string>(a: number, ab: (a: number) => number, bc: (b: number) => number, cd: (c: number) => string) => string (+25 overloads)pipe(
  5,                    // Start with 5
  (x: numberx) => x: numberx + 1,         // 5 + 1 = 6
  (x: numberx) => x: numberx * 2,         // 6 * 2 = 12
  (x: numberx) => `Result: ${x: numberx}` // 'Result: 12'
);
// 'Result: 12&

Why Use `pipe`?

Without `pipe`

Nested function calls are hard to read:

// ❌ Hard to read - inside out
const const result: stringresult = const format: (x: number) => stringformat(const multiply: (a: number, b: number) => numbermultiply(const add: (a: number, b: number) => numberadd(5, 1), 2));

Or intermediate variables are verbose:

// ❌ Too many variables
const const step1: numberstep1 = const add: (a: number, b: number) => numberadd(5, 1);
const const step2: numberstep2 = const multiply: (a: number, b: number) => numbermultiply(const step1: numberstep1, 2);
const const result: stringresult = const format: (x: number) => stringformat(const step2: numberstep2);

With `pipe`

import { import ResultResult } from '@praha/byethrow';

// ✅ Clear, left-to-right flow
const const result: stringresult = import ResultResult.const pipe: <number, number, number, string>(a: number, ab: (a: number) => number, bc: (b: number) => number, cd: (c: number) => string) => string (+25 overloads)pipe(
  5,
  (x: numberx) => const add: (a: number, b: number) => numberadd(x: numberx, 1),
  (x: numberx) => const multiply: (a: number, b: number) => numbermultiply(x: numberx, 2),
  const format: (x: number) => stringformat
);

Using `pipe` with Results

The real power of pipe comes when working with Results. All the transformation functions in @praha/byethrow are designed to work with pipe:

import { import ResultResult } from '@praha/byethrow';

const const result: Result.Result<number, never>result = import ResultResult.const pipe: <Result.Result<10, never>, Result.Result<number, never>, Result.Result<number, never>>(a: Result.Result<10, never>, ab: (a: Result.Result<10, never>) => Result.Result<number, never>, bc: (b: Result.Result<number, never>) => Result.Result<number, never>) => Result.Result<number, never> (+25 overloads)pipe(
  import ResultResult.const succeed: <10>(value: 10) => Result.Result<10, never> (+1 overload)succeed(10),
  import ResultResult.const map: <Result.Result<10, never>, number>(fn: (a: 10) => number) => (result: Result.Result<10, never>) => Result.Result<number, never> (+1 overload)map((x: 10x) => x: 10x * 2),
  import ResultResult.const map: <Result.Result<number, never>, number>(fn: (a: number) => number) => (result: Result.Result<number, never>) => Result.Result<number, never> (+1 overload)map((x: numberx) => x: numberx + 5),
);
// { type: 'Success', value: 25 }

How `pipe` Handles Async

When any function in the pipe returns a Promise, the result becomes a Promise:

import { import ResultResult } from '@praha/byethrow';

type type User = {
    id: string;
    name: string;
}
User = { id: stringid: string; name: stringname: string; };

const const fetchUser: (id: string) => Result.ResultAsync<User, string>fetchUser = async (id: stringid: string): import ResultResult.type ResultAsync<T, E> = Promise<Result.Result<T, E>>An asynchronous variant of
Result
, wrapped in a Promise.
@typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@exampleimport { Result } from '@praha/byethrow';

const fetchData = async (): Result.ResultAsync<string, Error> => {
  try {
    const data = await fetch('...');
    return { type: 'Success', value: await data.text() };
  } catch (err) {
    return { type: 'Failure', error: err as Error };
  }
};
@categoryCore  TypesResultAsync<type User = {
    id: string;
    name: string;
}
User, string> => {
  const const response: Responseresponse = await function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)MDN Referencefetch(`/api/users/${id: stringid}`);
  if (!const response: Responseresponse.Response.ok: booleanThe ok read-only property of the Response interface contains a Boolean stating whether the response was successful (status in the range 200-299) or not.
MDN Referenceok) {
    return import ResultResult.const fail: <"User not found">(error: "User not found") => Result.Result<never, "User not found"> (+1 overload)fail('User not found');
  }
  const const user: anyuser = await const response: Responseresponse.Body.json(): Promise<any>MDN Referencejson();
  return import ResultResult.const succeed: <any>(value: any) => Result.Result<any, never> (+1 overload)succeed(const user: anyuser);
};

const const result: Result.Result<string, string>result = await import ResultResult.const pipe: <Result.Result<"user-123", never>, Result.ResultAsync<User, string>, Result.ResultAsync<string, string>>(a: Result.Result<"user-123", never>, ab: (a: Result.Result<"user-123", never>) => Result.ResultAsync<User, string>, bc: (b: Result.ResultAsync<User, string>) => Result.ResultAsync<string, string>) => Result.ResultAsync<string, string> (+25 overloads)pipe(
  import ResultResult.const succeed: <"user-123">(value: "user-123") => Result.Result<"user-123", never> (+1 overload)succeed('user-123'),
  import ResultResult.const andThen: <Result.Result<"user-123", never>, Result.ResultAsync<User, string>>(fn: (a: "user-123") => Result.ResultAsync<User, string>) => (result: Result.Result<"user-123", never>) => Result.ResultAsync<User, string> (+1 overload)andThen(const fetchUser: (id: string) => Result.ResultAsync<User, string>fetchUser),
  import ResultResult.const map: <Result.ResultAsync<User, string>, string>(fn: (a: User) => string) => (result: Result.ResultAsync<User, string>) => Result.ResultAsync<string, string> (+1 overload)map((user: Useruser) => user: Useruser.name: stringname),
);

#Pipe Basics

#What is pipe?

#Why Use pipe?

#Without pipe

#With pipe

#Using pipe with Results