@zokugun/xtry 0.3.0 → 0.4.1

package/README.md

@@ -119,21 +119,21 @@ API reference
 ### Result helpers
 
 ```typescript
-export type Success<T> = { fails: false; value: T; error: null };
-export type Failure<E> = { fails: true; value: null; error: E };
-export type Result<T, E> = Success<T> | Failure<E>;
+type Success<T> = { fails: false; value: T; error: undefined };
+type Failure<E> = { fails: true; value: undefined; error: E };
+type Result<T, E> = Success<T> | Failure<E>;
 
-export function ok<T>(value: T): Success<T>;
-export function err<E>(error: E): Failure<E>;
+function ok<T>(value: T): Success<T>;
+function err<E>(error: E): Failure<E>;
 ```
 
 ### Try helpers
 
 ```typescript
-export function xtry<T, E>(func: () => Exclude<T, Promise<unknown>>, handler?: (error: unknown) => void | E): Result<T, E>;
-export function xatry<T, E>(func: (() => Exclude<T, Promise<unknown>>) | Promise<Exclude<T, Promise<unknown>>>, handler?: (error: unknown) => void | E): Promise<Result<T, E>>;
+function xtry<T, E>(func: () => Exclude<T, Promise<unknown>>, handler?: (error: unknown) => void | E): Result<T, E>;
+function xatry<T, E>(func: (() => Exclude<T, Promise<unknown>>) | Promise<Exclude<T, Promise<unknown>>>, handler?: (error: unknown) => void | E): Promise<Result<T, E>>;
 
-export function stringifyError(error: unknown): string;
+function stringifyError(error: unknown): string;
 ```
 
 Both helpers:
@@ -145,12 +145,15 @@ Both helpers:
 ### Partial helpers
 
 ```typescript
-export type YSuccess<T> = Success<T> & { success: true };
-export type YFailure<S> = { fails: false; success: false; type: S; value: null; error: null };
-export type YResult<T, E, S> = Failure<E> | YSuccess<T> | YFailure<S>;
-
-export function yok<T>(value: T): YSuccess<T>;
-export function yerr<S>(type: S): YFailure<S>;
+type YSuccess<T> = Success<T> & { success: true };
+type YFailure<M> = { fails: false; success: false; miscue: M; value: undefined; error: undefined };
+type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
+
+function yok<T>(value: T): YSuccess<T>;
+function yerr<M>(type: M): YFailure<M>;
+function yress<T, E>(result: Result<T, E>): Failure<E> | YSuccess<T>;
+function yresa<T, E>(promise: Promise<Result<T, E>>): Promise<Failure<E> | YSuccess<T>>;
+function yep<T>(result: Success<T>): YSuccess<T>;
 ```
 
 These helpers are useful when you need to separate soft rejections (`success: false`) from hard failures (`fails: true`).

package/lib/partial.d.ts

@@ -1,14 +1,17 @@
-import { type Failure, type Success } from './result.js';
-export type YResult<T, E, S> = Failure<E> | YSuccess<T> | YFailure<S>;
+import { type Result, type Failure, type Success } from './result.js';
+export type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
 export type YSuccess<T> = Success<T> & {
     success: true;
 };
-export type YFailure<S> = {
+export type YFailure<M> = {
     fails: false;
     success: false;
-    type: S;
-    value: null;
-    error: null;
+    miscue: M;
+    value: undefined;
+    error: undefined;
 };
 export declare function yok<T>(value: T): YSuccess<T>;
-export declare function yerr<S>(type: S): YFailure<S>;
+export declare function yerr<M>(miscue: M): YFailure<M>;
+export declare function yress<T, E>(result: Result<T, E>): Failure<E> | YSuccess<T>;
+export declare function yresa<T, E>(promise: Promise<Result<T, E>>): Promise<Failure<E> | YSuccess<T>>;
+export declare function yep<T>(result: Success<T>): YSuccess<T>;

package/lib/partial.js

@@ -3,15 +3,30 @@ export function yok(value) {
         fails: false,
         success: true,
         value,
-        error: null,
+        error: undefined,
     };
 }
-export function yerr(type) {
+export function yerr(miscue) {
     return {
         fails: false,
         success: false,
-        type,
-        value: null,
-        error: null,
+        miscue,
+        value: undefined,
+        error: undefined,
+    };
+}
+export function yress(result) {
+    if (result.fails) {
+        return result;
+    }
+    return yep(result);
+}
+export async function yresa(promise) {
+    return promise.then(yress);
+}
+export function yep(result) {
+    return {
+        ...result,
+        success: true,
     };
 }

package/lib/result.d.ts

@@ -1,13 +1,14 @@
 export type Success<T> = {
     fails: false;
     value: T;
-    error: null;
+    error: undefined;
 };
 export type Failure<E> = {
     fails: true;
-    value: null;
+    value: undefined;
     error: E;
 };
 export type Result<T, E> = Success<T> | Failure<E>;
+export declare function ok(): Success<void>;
 export declare function ok<T>(value: T): Success<T>;
 export declare function err<E>(error: E): Failure<E>;

package/lib/result.js

@@ -1,14 +1,14 @@
 export function ok(value) {
     return {
         fails: false,
-        value,
-        error: null,
+        value: value,
+        error: undefined,
     };
 }
 export function err(error) {
     return {
         fails: true,
-        value: null,
+        value: undefined,
         error,
     };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zokugun/xtry",
 	"description": "simple try/catch wrapper returning Result",
-	"version": "0.3.0",
+	"version": "0.4.1",
 	"author": {
 		"name": "Baptiste Augrain",
 		"email": "daiyam@zokugun.org"