Function: try()

Executes a function that may throw and wraps the result in a Result or ResultAsync.

You can use either a custom catch handler or rely on the safe: true option to assume the function cannot throw.

Type Param

The function type to execute (sync or async) or a Promise type.

Type Param

The error type to return if catch is used.

Examples

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

const const result: Result.Result<number, Error>result = import ResultResult.try<() => number, Error>(options: {
    try: () => number;
    catch: (error: unknown) => Error;
}): Result.Result<number, Error> (+3 overloads)
export try
Executes a function that may throw and wraps the result in a
Result
or
ResultAsync
.
You can use either a custom catch handler or rely on the safe: true option
to assume the function cannot throw.
@function@typeParamT  - The function type to execute (sync or async) or a Promise type.@typeParamE  - The error type to return if catch is used.@returnsA  Result or ResultAsync wrapping the function's return value or the caught error.@exampleSync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => {
const x = Math.random() * 10 - 5;
if (x < 0) throw new Error('Negative!');
return x * 2;
},
catch: (error) => new Error('Oops!', { cause: error }),
});

// result is Result<number, Error>
@exampleSync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Math.random() + 1,
});

// result is Result<number, never>
@exampleAsync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => fetch('/api/data'),
catch: (error) => new Error('Fetch failed', { cause: error }),
});

// result is ResultAsync<Response, Error>
@exampleAsync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Promise.resolve('ok'),
});

// result is ResultAsync<string, never>
@categoryCreatorstry({
  try: () => numbertry: () => {
    const const x: numberx = var Math: MathAn intrinsic object that provides basic mathematics functionality and constants.Math.Math.random(): numberReturns a pseudorandom number between 0 and 1.random() * 10 - 5;
    if (const x: numberx < 0) throw new var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('Negative!');
    return const x: numberx * 2;
  },
  catch: (error: unknown) => Errorcatch: (error: unknownerror) => new var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('Oops!', { ErrorOptions.cause?: unknowncause: error: unknownerror }),
});

// result is Result<number, Error>

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

const const result: Result.Result<number, never>result = import ResultResult.try<() => number>(options: {
    safe: true;
    try: () => number;
}): Result.Result<number, never> (+3 overloads)
export try
Executes a function that may throw and wraps the result in a
Result
or
ResultAsync
.
You can use either a custom catch handler or rely on the safe: true option
to assume the function cannot throw.
@function@typeParamT  - The function type to execute (sync or async) or a Promise type.@typeParamE  - The error type to return if catch is used.@returnsA  Result or ResultAsync wrapping the function's return value or the caught error.@exampleSync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => {
const x = Math.random() * 10 - 5;
if (x < 0) throw new Error('Negative!');
return x * 2;
},
catch: (error) => new Error('Oops!', { cause: error }),
});

// result is Result<number, Error>
@exampleSync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Math.random() + 1,
});

// result is Result<number, never>
@exampleAsync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => fetch('/api/data'),
catch: (error) => new Error('Fetch failed', { cause: error }),
});

// result is ResultAsync<Response, Error>
@exampleAsync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Promise.resolve('ok'),
});

// result is ResultAsync<string, never>
@categoryCreatorstry({
  safe: truesafe: true,
  try: () => numbertry: () => var Math: MathAn intrinsic object that provides basic mathematics functionality and constants.Math.Math.random(): numberReturns a pseudorandom number between 0 and 1.random() + 1,
});

// result is Result<number, never>

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

const const result: Result.ResultAsync<Response, Error>result = import ResultResult.try<() => Promise<Response>, Error>(options: {
    try: () => Promise<Response>;
    catch: (error: unknown) => Error;
}): Result.ResultAsync<Response, Error> (+3 overloads)
export try
Executes a function that may throw and wraps the result in a
Result
or
ResultAsync
.
You can use either a custom catch handler or rely on the safe: true option
to assume the function cannot throw.
@function@typeParamT  - The function type to execute (sync or async) or a Promise type.@typeParamE  - The error type to return if catch is used.@returnsA  Result or ResultAsync wrapping the function's return value or the caught error.@exampleSync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => {
const x = Math.random() * 10 - 5;
if (x < 0) throw new Error('Negative!');
return x * 2;
},
catch: (error) => new Error('Oops!', { cause: error }),
});

// result is Result<number, Error>
@exampleSync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Math.random() + 1,
});

// result is Result<number, never>
@exampleAsync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => fetch('/api/data'),
catch: (error) => new Error('Fetch failed', { cause: error }),
});

// result is ResultAsync<Response, Error>
@exampleAsync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Promise.resolve('ok'),
});

// result is ResultAsync<string, never>
@categoryCreatorstry({
  try: () => Promise<Response>try: () => function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)MDN Referencefetch('/api/data'),
  catch: (error: unknown) => Errorcatch: (error: unknownerror) => new var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('Fetch failed', { ErrorOptions.cause?: unknowncause: error: unknownerror }),
});

// result is ResultAsync<Response, Error>

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

const const result: Result.ResultAsync<string, never>result = import ResultResult.try<() => Promise<string>>(options: {
    safe: true;
    try: () => Promise<string>;
}): Result.ResultAsync<string, never> (+3 overloads)
export try
Executes a function that may throw and wraps the result in a
Result
or
ResultAsync
.
You can use either a custom catch handler or rely on the safe: true option
to assume the function cannot throw.
@function@typeParamT  - The function type to execute (sync or async) or a Promise type.@typeParamE  - The error type to return if catch is used.@returnsA  Result or ResultAsync wrapping the function's return value or the caught error.@exampleSync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => {
const x = Math.random() * 10 - 5;
if (x < 0) throw new Error('Negative!');
return x * 2;
},
catch: (error) => new Error('Oops!', { cause: error }),
});

// result is Result<number, Error>
@exampleSync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Math.random() + 1,
});

// result is Result<number, never>
@exampleAsync  try-catch
import { Result } from '@praha/byethrow';

const result = Result.try({
try: () => fetch('/api/data'),
catch: (error) => new Error('Fetch failed', { cause: error }),
});

// result is ResultAsync<Response, Error>
@exampleAsync  safe
import { Result } from '@praha/byethrow';

const result = Result.try({
safe: true,
try: () => Promise.resolve('ok'),
});

// result is ResultAsync<string, never>
@categoryCreatorstry({
  safe: truesafe: true,
  try: () => Promise<string>try: () => var Promise: PromiseConstructorRepresents the completion of an asynchronous operationPromise.PromiseConstructor.resolve<string>(value: string): Promise<string> (+2 overloads)Creates a new resolved promise for the provided value.
@paramvalue  A promise.@returnsA  promise whose internal state matches the provided promise.resolve('ok'),
});

// result is ResultAsync<string, never>

Call Signature

try<T, E>(options): ResultAsync<Awaited<ReturnType<T>>, E>

Type Parameters

T

T extends () => Promise<any>

E

E

Parameters

options

catch

(error) => E

try

T

Returns

ResultAsync<Awaited<ReturnType<T>>, E>

Call Signature

try<T>(options): ResultAsync<Awaited<ReturnType<T>>, never>

Type Parameters

T

T extends () => Promise<any>

Parameters

options

safe

true

try

T

Returns

ResultAsync<Awaited<ReturnType<T>>, never>

Call Signature

try<T, E>(options): Result<ReturnType<T>, E>

Type Parameters

T

T extends () => any

E

E

Parameters

options

catch

(error) => E

try

T

Returns

Result<ReturnType<T>, E>

Call Signature

try<T>(options): Result<ReturnType<T>, never>

Type Parameters

T

T extends () => any

Parameters

options

safe

true

try

T

Returns

Result<ReturnType<T>, never>

#Function: try()

#Type Param

#Type Param

#Examples

#Call Signature

#Type Parameters

#T

#E

#Parameters

#options

#catch

#try

#Returns

#Call Signature

#Type Parameters

#T

#Parameters

#options

#safe

#try

#Returns

#Call Signature

#Type Parameters

#T

#E

#Parameters

#options

#catch

#try

#Returns

#Call Signature

#Type Parameters

#T

#Parameters

#options

#safe

#try

#Returns

Function: try()

Type Param

Type Param

Examples

Call Signature

Type Parameters

T

E

Parameters

options

catch

try

Returns

Call Signature

Type Parameters

T

Parameters

options

safe

try

Returns

Call Signature

Type Parameters

T

E

Parameters

options

catch

try

Returns

Call Signature

Type Parameters

T

Parameters

options

safe

try

Returns