byethrow
  • 日本語

      • Function: bind()

      Chains another Result-producing computation and merges its success value into the existing object under the specified key.

      • If the original result is a Failure, it is returned as-is.
      • If the next result is a Failure, it is returned as-is.
      • If both are Success, a new object is returned by shallow-merging: the original success object and { [name]: nextSuccess }.

      This is useful for building up objects in a compositional and type-safe way, especially in validation or data-fetching pipelines.

      Type Param

      The key to assign the result of the fn computation.

      Type Param

      The input Result or ResultAsync.

      Type Param

      The result type returned by fn.

      Examples

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

const 
      const result: Result.Result<{
    age: 20;
    name: "Alice";
}, never>
      result       = 
      import Result
      Result      .
      const pipe: <Result.Result<{
    readonly name: "Alice";
}, never>, Result.Result<{
    age: 20;
    name: "Alice";
}, never>>(a: Result.Result<{
    readonly name: "Alice";
}, never>, ab: (a: Result.Result<{
    readonly name: "Alice";
}, never>) => Result.Result<{
    age: 20;
    name: "Alice";
}, never>) => Result.Result<{
    age: 20;
    name: "Alice";
}, never> (+25 overloads)
      pipe      (      
  
      import Result
      Result      .
      const succeed: <{
    readonly name: "Alice";
}>(value: {
    readonly name: "Alice";
}) => Result.Result<{
    readonly name: "Alice";
}, never> (+1 overload)
      succeed      ({ 
      name: "Alice"
      name      : 'Alice' }),      
  
      import Result
      Result      .
      const bind: <"age", Result.Result<{
    readonly name: "Alice";
}, never>, Result.Result<20, never>>(name: "age", fn: (a: {
    readonly name: "Alice";
}) => Result.Result<20, never>) => (result: Result.Result<{
    readonly name: "Alice";
}, never>) => Result.Result<{
    age: 20;
    name: "Alice";
}, never> (+1 overload)
      bind      ('age', (
      user: {
    readonly name: "Alice";
}
      user      ) => 
      import Result
      Result      .
      const succeed: <20>(value: 20) => Result.Result<20, never> (+1 overload)
      succeed      (20)),      
);
// { type: 'Success', value: { name: 1, age: 20 } }
      import { 
      import Result
      Result       } from '@praha/byethrow';      

const 
      const result: Result.Result<{
    [x: string]: never;
    [x: number]: never;
    [x: symbol]: never;
}, "error">
      result       = 
      import Result
      Result      .
      const pipe: <Result.Result<never, "error">, Result.Result<{
    [x: string]: never;
    [x: number]: never;
    [x: symbol]: never;
}, "error">>(a: Result.Result<never, "error">, ab: (a: Result.Result<never, "error">) => Result.Result<{
    [x: string]: never;
    [x: number]: never;
    [x: symbol]: never;
}, "error">) => Result.Result<{
    [x: string]: never;
    [x: number]: never;
    [x: symbol]: never;
}, "error"> (+25 overloads)
      pipe      (      
  
      import Result
      Result      .
      const fail: <"error">(error: "error") => Result.Result<never, "error"> (+1 overload)
      fail      ('error'),      
  
      import Result
      Result      .
      const bind: <"age", Result.Result<never, "error">, Result.Result<20, never>>(name: "age", fn: (a: never) => Result.Result<20, never>) => (result: Result.Result<never, "error">) => Result.Result<{
    [x: string]: never;
    [x: number]: never;
    [x: symbol]: never;
}, "error"> (+1 overload)
      bind      ('age', (
      user: never
      user      ) => 
      import Result
      Result      .
      const succeed: <20>(value: 20) => Result.Result<20, never> (+1 overload)
      succeed      (20)),      
);
// { type: 'Failure', error: 'error' }
      import { 
      import Result
      Result       } from '@praha/byethrow';      

const 
      const result: Result.Result<{
    age: never;
    name: "Alice";
}, "error">
      result       = 
      import Result
      Result      .
      const pipe: <Result.Result<{
    readonly name: "Alice";
}, never>, Result.Result<{
    age: never;
    name: "Alice";
}, "error">>(a: Result.Result<{
    readonly name: "Alice";
}, never>, ab: (a: Result.Result<{
    readonly name: "Alice";
}, never>) => Result.Result<{
    age: never;
    name: "Alice";
}, "error">) => Result.Result<{
    age: never;
    name: "Alice";
}, "error"> (+25 overloads)
      pipe      (      
  
      import Result
      Result      .
      const succeed: <{
    readonly name: "Alice";
}>(value: {
    readonly name: "Alice";
}) => Result.Result<{
    readonly name: "Alice";
}, never> (+1 overload)
      succeed      ({ 
      name: "Alice"
      name      : 'Alice' }),      
  
      import Result
      Result      .
      const bind: <"age", Result.Result<{
    readonly name: "Alice";
}, never>, Result.Result<never, "error">>(name: "age", fn: (a: {
    readonly name: "Alice";
}) => Result.Result<never, "error">) => (result: Result.Result<{
    readonly name: "Alice";
}, never>) => Result.Result<{
    age: never;
    name: "Alice";
}, "error"> (+1 overload)
      bind      ('age', (
      user: {
    readonly name: "Alice";
}
      user      ) => 
      import Result
      Result      .
      const fail: <"error">(error: "error") => Result.Result<never, "error"> (+1 overload)
      fail      ('error')),      
);
// { type: 'Failure', error: 'error' }

      See

      pipe - It is recommended to use this function with the pipe function for better readability and composability.

      Call Signature

      bind<N, R1, R2>(name, fn): (result) => InferSuccess<R1> extends object ? ResultFor<R1 | R2, { [K in string | number | symbol]: K extends Exclude<keyof InferSuccess, N> ? InferSuccess[K] : InferSuccess<R2> }, InferFailure<R1> | InferFailure<R2>> : unknown

      Type Parameters

      N

      N extends string

      R1

      R1 extends ResultMaybeAsync<any, any>

      R2

      R2 extends ResultMaybeAsync<any, any>

      Parameters

      name

      N

      fn

      (a) => R2

      Returns

      (result): InferSuccess<R1> extends object ? ResultFor<R1 | R2, { [K in string | number | symbol]: K extends Exclude<keyof InferSuccess, N> ? InferSuccess[K] : InferSuccess<R2> }, InferFailure<R1> | InferFailure<R2>> : unknown

      Parameters

      result

      R1

      Returns

      InferSuccess<R1> extends object ? ResultFor<R1 | R2, { [K in string | number | symbol]: K extends Exclude<keyof InferSuccess, N> ? InferSuccess[K] : InferSuccess<R2> }, InferFailure<R1> | InferFailure<R2>> : unknown

      Call Signature

      bind<N, F>(name, fn): <R1>(result) => Parameters<F>[0] extends object ? ResultFor<R1 | ReturnType<F>, { [K in string | number | symbol]: K extends Exclude<keyof any[any], N> ? any[any][K] : InferSuccess<F> }, InferFailure<R1> | InferFailure<F>> : unknown

      Type Parameters

      N

      N extends string

      F

      F extends (a) => ResultMaybeAsync<any, any>

      Parameters

      name

      N

      fn

      F

      Returns

      <R1>(result): Parameters<F>[0] extends object ? ResultFor<R1 | ReturnType<F>, { [K in string | number | symbol]: K extends Exclude<keyof any[any], N> ? any[any][K] : InferSuccess<F> }, InferFailure<R1> | InferFailure<F>> : unknown

      Type Parameters

      R1

      R1 extends ResultMaybeAsync<Parameters<F>[0], any>

      Parameters

      result

      R1

      Returns

      Parameters<F>[0] extends object ? ResultFor<R1 | ReturnType<F>, { [K in string | number | symbol]: K extends Exclude<keyof any[any], N> ? any[any][K] : InferSuccess<F> }, InferFailure<R1> | InferFailure<F>> : unknown