logo
byethrow
  • Guide
  • Examples
  • API Reference
    @praha/byethrow
    Modules
    Result
    Types
    Type Alias: Failure<E>
    Type Alias: InferFailure<T>
    Type Alias: InferSuccess<T>
    Type Alias: Result<T, E>
    Type Alias: ResultAsync<T, E>
    Type Alias: ResultFor<R, T, E>
    Type Alias: ResultMaybeAsync<T, E>
    Type Alias: Success<T>
    Functions
    Function: andThen()
    Function: andThrough()
    Function: assertFailure()
    Function: assertSuccess()
    Function: bind()
    Function: collect()
    Function: do()
    Function: fail()
    Function: inspect()
    Function: inspectError()
    Function: isFailure()
    Function: isResult()
    Function: isSuccess()
    Function: map()
    Function: mapError()
    Function: orElse()
    Function: parse()
    Function: pipe()
    Function: sequence()
    Function: succeed()
    Function: try()
    Function: unwrap()
    Function: unwrapError()
    📝 Edit this page

    Last Updated:

    Previous pageFunction: sequence()Next pageFunction: try()

    #Function: succeed()

    Creates a Success result from a given value. Automatically wraps the value in a Promise if it is asynchronous.

    #Type Param

    The type of the value to wrap.

    #Examples

    import { 
    import Result
    Result
    } from '@praha/byethrow';
    const
    const result: Result.Result<42, never>
    result
    =
    import Result
    Result
    .
    const succeed: <42>(value: 42) => Result.Result<42, never> (+1 overload)
    succeed
    (42);
    // Result.Result<number, never>
    import { 
    import Result
    Result
    } from '@praha/byethrow';
    const
    const result: Result.ResultAsync<number, never>
    result
    =
    import Result
    Result
    .
    const succeed: <Promise<number>>(value: Promise<number>) => Result.ResultAsync<number, never> (+1 overload)
    succeed
    (
    var Promise: PromiseConstructor

    Represents the completion of an asynchronous operation

    Promise
    .
    PromiseConstructor.resolve<number>(value: number): Promise<number> (+2 overloads)

    Creates a new resolved promise for the provided value.

    @paramvalue A promise.@returnsA promise whose internal state matches the provided promise.
    resolve
    (42));
    // Result.ResultAsync<number, never>
    import { 
    import Result
    Result
    } from '@praha/byethrow';
    const
    const result: Result.Result<void, never>
    result
    =
    import Result
    Result
    .
    const succeed: () => Result.ResultFor<never, void, never> (+1 overload)
    succeed
    ();
    // Result.Result<void, never>

    #See

    collect - For collect multiple Results into a single Result.

    #Call Signature

    succeed(): Result<void, never>

    Defined in: functions/succeed.ts:44

    #Returns

    Result<void, never>

    #Call Signature

    succeed<T>(value): ResultFor<T, Awaited<T>, never>

    Defined in: functions/succeed.ts:45

    #Type Parameters

    #T

    T

    #Parameters

    #value

    T

    #Returns

    ResultFor<T, Awaited<T>, never>