byethrow

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

type 
type User = {
    id: string;
    name: string;
}User = { 
id: stringid: string; 
name: stringname: string };

const 
const fetchUser: (id: string) => Result.ResultAsync<User, Error>fetchUser = 
import ResultResult.
fn<(id: string) => Promise<User>, Error>(options: {
    try: (id: string) => Promise<User>;
    catch: (error: unknown) => Error;
}): (id: string) => Result.ResultAsync<User, Error> (+3 overloads)
export fn
Wraps a function that may throw and returns a new function that returns 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  new function that returns a Result or ResultAsync wrapping the original function's return value or the caught error.@example
Sync  try-catch
import { Result } from '@praha/byethrow';

const fn = Result.fn({
try: (x: number) => {
if (x < 0) throw new Error('Negative!');
return x * 2;
},
catch: (error) => new Error('Oops!', { cause: error }),
});

const result = fn(5); // Result.Result<number, Error>@example
Sync  safe
import { Result } from '@praha/byethrow';

const fn = Result.fn({
safe: true,
try: (x: number) => x + 1,
});

const result = fn(1); // Result.Result<number, never>@example
Async  try-catch
import { Result } from '@praha/byethrow';

const fn = Result.fn({
try: async (id: string) => await fetch(`/api/data/${id}`),
catch: (error) => new Error('Oops!', { cause: error }),
});

const result = await fn('abc'); // Result.ResultAsync<Response, Error>@example
Async  safe
import { Result } from '@praha/byethrow';

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

const result = await fn(); // Result.ResultAsync<string, never>@categoryCreatorsfn({
  
try: (id: string) => Promise<User>try: async (
id: stringid: string): 
interface Promise<T>
Represents the completion of an asynchronous operationPromise<
type User = {
    id: string;
    name: string;
}User> => {
    const 
const response: Responseresponse = await 
function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
MDN Referencefetch(`/api/users/${
id: stringid}`);
    if (!
const response: Responseresponse.
Response.ok: boolean
The ok read-only property of the Response interface contains a Boolean stating whether the response was successful (status in the range 200-299) or not.
MDN Referenceok) throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error(`HTTP ${
const response: Responseresponse.
Response.status: number
The status read-only property of the Response interface contains the HTTP status codes of the response.
MDN Referencestatus}`);
    return 
const response: Responseresponse.
Body.json(): Promise<any>
MDN Referencejson();
  },
  
catch: (error: unknown) => Errorcatch: (
error: unknownerror) => new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)Error('Failed to fetch user', { 
ErrorOptions.cause?: unknowncause: 
error: unknownerror }),
});

const 
const result: Result.Result<User, Error>result = await 
const fetchUser: (id: string) => Result.ResultAsync<User, Error>fetchUser('u_123');