logo
byethrow
Guide
Examples
API Reference
Guide
Examples
API Reference
logo
byethrow
@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: combine()
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: succeed()
Function: try()
Function: unwrap()
Function: unwrapError()

Last Updated:

Previous PageFunction: pipe()
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<number, never>
result
=
import Result
Result
.
const succeed: <number>(value: number) => Result.Result<number, 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

combine - For combining 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>