pipe 関数の扱い方

pipe 関数は @praha/byethrow の中核をなす機能の一つです。複数の操作を読みやすい左から右への方式で連結できます。

`pipe` とは？

pipe は初期値を受け取り、一連の関数に順番に渡していきます。各関数は前の関数の出力を受け取ります。

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,                    // 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&

なぜ `pipe` を使うのか？

`pipe` を使わない場合

ネストした関数呼び出しは読みにくいです。

// ❌ 読みにくい - 内側から外側へ読む必要がある
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));

中間変数を使うと冗長になります。

// ❌ 変数が多すぎる
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);

`pipe` を使う場合

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,
  (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
);

`Result` と `pipe` を組み合わせる

pipe の真価は Result と一緒に使うときに発揮されます。 @praha/byethrow のすべての変換関数は 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 }

`pipe` の非同期処理

パイプ内のいずれかの関数が Promise を返すと、結果は 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: RequestInfo | URL, init?: RequestInit): Promise<Response>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 関数の扱い方

#pipe とは？

#なぜ pipe を使うのか？

#pipe を使わない場合

#pipe を使う場合

#Result と pipe を組み合わせる