byethrow
  • 日本語

      • Result を確認する

      Result を作成または受け取った後、その内容にアクセスする前に、それが成功か失敗かを判定する必要があります。 このセクションでは、これを安全に行うための型ガード関数について説明します。

      isSuccess で成功をチェックする

      isSuccess 関数は、Result が Success かどうかをチェックする型ガード関数です。

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

const 
      const result: Result.Result<number, string>
      result      : 
      import Result
      Result      .
      type Result<T, E> = Result.Success<T> | Result.Failure<E>
      A union type representing either a success or a failure.
      @typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@example
      import { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
      @categoryCore  Types
      Result      <number, string> = 
      import Result
      Result      .
      const succeed: <42>(value: 42) => Result.Result<42, never> (+1 overload)
      succeed      (42);      

if (
      import Result
      Result      .
      const isSuccess: <number>(result: Result.Result<number, unknown>) => result is Result.Success<number>
      Type guard to check if a
Result
is a
Success
.
      @function@typeParamT  - The type of the success value.@paramresult  - The Result to check.@returnstrue if the result is a Success, otherwise false.@example
      import { Result } from '@praha/byethrow';

const result: Result.Result<number, string> = { type: 'Success', value: 10 };
if (Result.isSuccess(result)) {
  console.log(result.value); // Safe access to value
}
      @categoryType  Guards
      isSuccess      (
      const result: Result.Result<number, string>
      result      )) {      
  // TypeScript はここで result が Success<number> であることを知っている
  
      var console: Console
      The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
      

      The module exports two specific components:
      

        

      • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
        • 

      • A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.
        • 

      

      Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
      

      Example using the global console:
      

      console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
      

      Example using the Console class:
      

      const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
      @seesource
      console      .
      Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
      Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
      

      const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
      

      See util.format() for more information.
      @sincev0 .1.100
      log      (
      const result: Result.Success<number>
      result      .
      value: number
      value      ); // 42      
}

      型の絞り込み

      isSuccess 関数を使用することで、型を絞り込み value プロパティへ安全にアクセス出来るようになります。

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

const 
      const processResult: (result: Result.Result<string, Error>) => string
      processResult       = (
      result: Result.Result<string, Error>
      result      : 
      import Result
      Result      .
      type Result<T, E> = Result.Success<T> | Result.Failure<E>
      A union type representing either a success or a failure.
      @typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@example
      import { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
      @categoryCore  Types
      Result      <string, Error>) => {      
  if (
      import Result
      Result      .
      const isSuccess: <string>(result: Result.Result<string, unknown>) => result is Result.Success<string>
      Type guard to check if a
Result
is a
Success
.
      @function@typeParamT  - The type of the success value.@paramresult  - The Result to check.@returnstrue if the result is a Success, otherwise false.@example
      import { Result } from '@praha/byethrow';

const result: Result.Result<number, string> = { type: 'Success', value: 10 };
if (Result.isSuccess(result)) {
  console.log(result.value); // Safe access to value
}
      @categoryType  Guards
      isSuccess      (
      result: Result.Result<string, Error>
      result      )) {      
    // ✅ TypeScript は `value` が存在することを知っている
    return 
      result: Result.Success<string>
      result      .
      value: string
      value      .
      String.toUpperCase(): string
      Converts all the alphabetic characters in a string to uppercase.
      toUpperCase      ();      
  }
  // ✅ TypeScript はここで `error` が存在することを知っている
  return `Error: ${
      result: Result.Failure<Error>
      result      .
      error: Error
      error      .
      Error.message: string
      message      }`;      
};

      isFailure で失敗をチェックする

      isFailure 関数は、Result が Failure かどうかをチェックする型ガード関数です。

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

const 
      const result: Result.Result<number, string>
      result      : 
      import Result
      Result      .
      type Result<T, E> = Result.Success<T> | Result.Failure<E>
      A union type representing either a success or a failure.
      @typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@example
      import { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
      @categoryCore  Types
      Result      <number, string> = 
      import Result
      Result      .
      const fail: <"Something went wrong">(error: "Something went wrong") => Result.Result<never, "Something went wrong"> (+1 overload)
      fail      ('Something went wrong');      

if (
      import Result
      Result      .
      const isFailure: <string>(result: Result.Result<unknown, string>) => result is Result.Failure<string>
      Type guard to check if a
Result
is a
Failure
.
      @function@typeParamE  - The type of the error value.@paramresult  - The Result to check.@returnstrue if the result is a Failure, otherwise false.@example
      import { Result } from '@praha/byethrow';

const result: Result.Result<number, string> = { type: 'Failure', error: 'Something went wrong' };
if (Result.isFailure(result)) {
  console.error(result.error); // Safe access to error
}
      @categoryType  Guards
      isFailure      (
      const result: Result.Result<number, string>
      result      )) {      
  // TypeScript はここで result が Failure<string> であることを知っている
  
      var console: Console
      The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
      

      The module exports two specific components:
      

        

      • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
        • 

      • A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.
        • 

      

      Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
      

      Example using the global console:
      

      console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
      

      Example using the Console class:
      

      const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
      @seesource
      console      .
      Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
      Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
      

      const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
      

      See util.format() for more information.
      @sincev0 .1.100
      log      (
      const result: Result.Failure<string>
      result      .
      error: string
      error      ); // "Something went wrong"      
}

      早期リターン

      よくあるパターンは、最初に失敗をチェックして早期リターンすることです。

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

const 
      const handleUserLookup: (result: Result.Result<User, string>) => User | null
      handleUserLookup       = (
      result: Result.Result<User, string>
      result      : 
      import Result
      Result      .
      type Result<T, E> = Result.Success<T> | Result.Failure<E>
      A union type representing either a success or a failure.
      @typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@example
      import { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
      @categoryCore  Types
      Result      <
      type User = {
    id: number;
    name: string;
}
      User      , string>) => {      
  if (
      import Result
      Result      .
      const isFailure: <string>(result: Result.Result<unknown, string>) => result is Result.Failure<string>
      Type guard to check if a
Result
is a
Failure
.
      @function@typeParamE  - The type of the error value.@paramresult  - The Result to check.@returnstrue if the result is a Failure, otherwise false.@example
      import { Result } from '@praha/byethrow';

const result: Result.Result<number, string> = { type: 'Failure', error: 'Something went wrong' };
if (Result.isFailure(result)) {
  console.error(result.error); // Safe access to error
}
      @categoryType  Guards
      isFailure      (
      result: Result.Result<User, string>
      result      )) {      
    
      var console: Console
      The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
      

      The module exports two specific components:
      

        

      • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
        • 

      • A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.
        • 

      

      Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
      

      Example using the global console:
      

      console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
      

      Example using the Console class:
      

      const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
      @seesource
      console      .
      Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)
      Prints to stderr with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
      

      const code = 5;
console.error('error #%d', code);
// Prints: error #5, to stderr
console.error('error', code);
// Prints: error 5, to stderr
      

      If formatting elements (e.g. %d) are not found in the first string then
util.inspect() is called on each argument and the
resulting string values are concatenated. See util.format()
for more information.
      @sincev0 .1.100
      error      ('Failed to find user:', 
      result: Result.Failure<string>
      result      .
      error: string
      error      );      
    return null;
  }

  // 早期リターン後、TypeScript は result が Success であることを知っている
  return 
      result: Result.Success<User>
      result      .
      value: User
      value      ;      
};

      isResult で値が Result かどうかをチェックする

      isResult 関数は、値が Result であるかどうかをチェックする型ガード関数です。 任意の値が Result かどうかをチェックする必要がある場合に便利です。

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

const 
      const maybeResult: unknown
      maybeResult      : unknown = 
      import Result
      Result      .
      const succeed: <42>(value: 42) => Result.Result<42, never> (+1 overload)
      succeed      (42);      

if (
      import Result
      Result      .
      const isResult: <unknown, unknown>(result: unknown) => result is Result.Result<unknown, unknown>
      Type guard to check if a value is a
Result
.
      @function@typeParamT  - The type of the success value.@typeParamE  - The type of the error value.@paramresult  - The value to check.@returnstrue if the value is a Result, otherwise false.@example
      import { Result } from '@praha/byethrow';

const value: unknown = { type: 'Success', value: 42 };
if (Result.isResult(value)) {
  // value is now typed as Result<unknown, unknown>
  console.log(value.type); // 'Success' or 'Failure'
}
      @categoryType  Guards
      isResult      (
      const maybeResult: unknown
      maybeResult      )) {      
  // TypeScript は maybeResult が Result<unknown, unknown> であることを知っている
  if (
      import Result
      Result      .
      const isSuccess: <unknown>(result: Result.Result<unknown, unknown>) => result is Result.Success<unknown>
      Type guard to check if a
Result
is a
Success
.
      @function@typeParamT  - The type of the success value.@paramresult  - The Result to check.@returnstrue if the result is a Success, otherwise false.@example
      import { Result } from '@praha/byethrow';

const result: Result.Result<number, string> = { type: 'Success', value: 10 };
if (Result.isSuccess(result)) {
  console.log(result.value); // Safe access to value
}
      @categoryType  Guards
      isSuccess      (
      const maybeResult: Result.Result<unknown, unknown>
      maybeResult      )) {      
    
      var console: Console
      The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
      

      The module exports two specific components:
      

        

      • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
        • 

      • A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.
        • 

      

      Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
      

      Example using the global console:
      

      console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
      

      Example using the Console class:
      

      const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
      @seesource
      console      .
      Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
      Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
      

      const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
      

      See util.format() for more information.
      @sincev0 .1.100
      log      (
      const maybeResult: Result.Success<unknown>
      maybeResult      .
      value: unknown
      value      );      
  }
}

      汎用ユーティリティ

      よくあるパターンは、様々な型を受け入れて Result を特別に扱う関数を書くことです。

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

const 
      const stringify: (value: unknown) => string
      stringify       = (
      value: unknown
      value      : unknown): string => {      
  if (
      import Result
      Result      .
      const isResult: <unknown, unknown>(result: unknown) => result is Result.Result<unknown, unknown>
      Type guard to check if a value is a
Result
.
      @function@typeParamT  - The type of the success value.@typeParamE  - The type of the error value.@paramresult  - The value to check.@returnstrue if the value is a Result, otherwise false.@example
      import { Result } from '@praha/byethrow';

const value: unknown = { type: 'Success', value: 42 };
if (Result.isResult(value)) {
  // value is now typed as Result<unknown, unknown>
  console.log(value.type); // 'Success' or 'Failure'
}
      @categoryType  Guards
      isResult      (
      value: unknown
      value      )) {      
    if (
      import Result
      Result      .
      const isSuccess: <unknown>(result: Result.Result<unknown, unknown>) => result is Result.Success<unknown>
      Type guard to check if a
Result
is a
Success
.
      @function@typeParamT  - The type of the success value.@paramresult  - The Result to check.@returnstrue if the result is a Success, otherwise false.@example
      import { Result } from '@praha/byethrow';

const result: Result.Result<number, string> = { type: 'Success', value: 10 };
if (Result.isSuccess(result)) {
  console.log(result.value); // Safe access to value
}
      @categoryType  Guards
      isSuccess      (
      value: Result.Result<unknown, unknown>
      value      )) {      
      return `Success: ${
      var JSON: JSON
      An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
      JSON      .
      JSON.stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string (+1 overload)
      Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
      @paramvalue  A JavaScript value, usually an object or array, to be converted.@paramreplacer  A function that transforms the results.@paramspace  Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.@throws{TypeError} If a circular reference or a BigInt value is found.
      stringify      (
      value: Result.Success<unknown>
      value      .
      value: unknown
      value      )}`;      
    }
    return `Failure: ${
      var JSON: JSON
      An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
      JSON      .
      JSON.stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string (+1 overload)
      Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
      @paramvalue  A JavaScript value, usually an object or array, to be converted.@paramreplacer  A function that transforms the results.@paramspace  Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.@throws{TypeError} If a circular reference or a BigInt value is found.
      stringify      (
      value: Result.Failure<unknown>
      value      .
      error: unknown
      error      )}`;      
  }
  return 
      var JSON: JSON
      An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
      JSON      .
      JSON.stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string (+1 overload)
      Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
      @paramvalue  A JavaScript value, usually an object or array, to be converted.@paramreplacer  A function that transforms the results.@paramspace  Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.@throws{TypeError} If a circular reference or a BigInt value is found.
      stringify      (
      value: unknown
      value      );      
};

      リファレンス

      関数目的
      isSuccess(result)Result が Success かチェック
      isFailure(result)Result が Failure かチェック
      isResult(value)値が Result かどうかをチェック