clutchit 0.0.14 → 0.0.16

package/CHANGELOG.md

@@ -14,7 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Try<T, E>` — synchronous typed error container with `Ok` and `Err` variants
 - `TryAsync<T, E>` — async equivalent backed by `Promise<Try<T, E>>`, implements `PromiseLike`
 - `ok()`, `err()`, `okAsync()`, `errAsync()` — standalone constructors
-- `Do` / `DoAsync` — generator-based Do notation with optional context parameter
+- `attempt` — generator-based sequential chaining (overloaded for sync and async) with optional context parameter
 - Instance methods: `map`, `mapErr`, `andThen`, `orElse`, `tap`, `tapErr`, `andThrough`, `orThrough`, `catchFault`, `unwrapOr`, `match`
 - `fromPromise` — lift a `Promise` into a `TryAsync` with typed error mapping
 - `fromSafePromise` — lift a never-rejecting promise into `TryAsync<T, never>`

package/README.md

@@ -19,7 +19,7 @@ npm install clutchit
 
 | Import | Description |
 |---|---|
-| `clutchit/unthrow` | `Try<T,E>`, `TryAsync<T,E>`, `Fault`, Do notation |
+| `clutchit/unthrow` | `Try<T,E>`, `TryAsync<T,E>`, `Fault`, `attempt` |
 | `clutchit/schedule` | Composable timing schedules — exponential, linear, fibonacci, cron, … |
 | `clutchit/retry` | Retry policy with backoff schedules and abort signal support |
 | `clutchit/timeout` | Timeout wrapper with `AbortSignal` propagation |
@@ -151,15 +151,15 @@ combineWithAllErrors([ok(1), err('a'), err('b')]);  // Err(['a', 'b'])
 race([okAsync(1), okAsync(2)]);
 ```
 
-### Do notation
+### attempt
 
-Generator-based sequential chaining. `yield*` unwraps `Ok`; any `Err` short-circuits the entire block.
+Generator-based sequential chaining. `yield*` unwraps `Ok`; any `Err` short-circuits the entire block. A single overloaded function handles both sync and async generators.
 
 ```ts
-import { Do, DoAsync } from 'clutchit/unthrow';
+import { attempt } from 'clutchit/unthrow';
 
 // Sync
-const result = Do(function* () {
+const result = attempt(function* () {
   const user  = yield* findUser(id);        // Try<User, NotFoundFault>
   const perms = yield* getPermissions(user); // Try<Perms, PermFault>
   return { user, perms };
@@ -167,7 +167,7 @@ const result = Do(function* () {
 });
 
 // Async
-const result = DoAsync(async function* () {
+const result = attempt(async function* () {
   const user  = yield* fetchUser(id);         // TryAsync<User, NetworkFault>
   const order = yield* createOrder(user);     // TryAsync<Order, OrderFault>
   return order;
@@ -175,7 +175,7 @@ const result = DoAsync(async function* () {
 });
 
 // With context
-const result = Do({ db }, function* (ctx) {
+const result = attempt({ db }, function* (ctx) {
   const user = yield* ctx.db.findUser(id);
   return user;
 });

package/dist/unthrow/attempt.d.ts

@@ -0,0 +1,9 @@
+import { type Try, Err } from './try.js';
+import { TryAsync } from './try.async.js';
+type InferFault<Y> = Y extends Err<never, infer E> ? E : never;
+export declare function attempt<T, Y extends Err<never, any>>(generator: () => Generator<Y, T>): Try<T, InferFault<Y>>;
+export declare function attempt<C, T, Y extends Err<never, any>>(ctx: C, generator: (ctx: C) => Generator<Y, T>): Try<T, InferFault<Y>>;
+export declare function attempt<T, Y extends Err<never, any>>(generator: () => AsyncGenerator<Y, T>): TryAsync<T, InferFault<Y>>;
+export declare function attempt<C, T, Y extends Err<never, any>>(ctx: C, generator: (ctx: C) => AsyncGenerator<Y, T>): TryAsync<T, InferFault<Y>>;
+export {};
+//# sourceMappingURL=attempt.d.ts.map

package/dist/unthrow/attempt.js

@@ -0,0 +1,23 @@
+import { ok } from './try.js';
+import { TryAsync } from './try.async.js';
+// Implementation
+export function attempt(ctxOrGenerator, generator) {
+    const gen = typeof ctxOrGenerator === 'function'
+        ? ctxOrGenerator()
+        : generator(ctxOrGenerator);
+    if (Symbol.asyncIterator in gen) {
+        return new TryAsync((async () => {
+            const next = await gen.next();
+            while (!next.done) {
+                return next.value;
+            }
+            return ok(next.value);
+        })());
+    }
+    const next = gen.next();
+    while (!next.done) {
+        return next.value;
+    }
+    return ok(next.value);
+}
+//# sourceMappingURL=attempt.js.map

package/dist/unthrow/fault-of.d.ts

@@ -0,0 +1,4 @@
+import { type Try } from './try.js';
+import { type TryAsync } from './try.async.js';
+export type FaultOf<T extends (...args: any[]) => any> = ReturnType<T> extends TryAsync<any, infer E> ? E : ReturnType<T> extends Try<any, infer E> ? E : never;
+//# sourceMappingURL=fault-of.d.ts.map

package/dist/unthrow/fault-of.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fault-of.js.map

package/dist/unthrow/index.d.ts

@@ -9,6 +9,7 @@ export declare namespace Fault {
 }
 export { type Try, Ok, Err, ok, err } from './try.js';
 export { TryAsync, okAsync, errAsync } from './try.async.js';
+export { type FaultOf } from './fault-of.js';
 export { fromPromise, fromSafePromise, fromThrowable, fromAsyncThrowable, combine, combineWithAllErrors, unwrap, flatten, race, } from './helpers.js';
-export { Do, DoAsync } from './do.js';
+export { attempt } from './attempt.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/unthrow/index.js

@@ -13,6 +13,6 @@ export var Fault;
 export { Ok, Err, ok, err } from './try.js';
 export { TryAsync, okAsync, errAsync } from './try.async.js';
 export { fromPromise, fromSafePromise, fromThrowable, fromAsyncThrowable, combine, combineWithAllErrors, unwrap, flatten, race, } from './helpers.js';
-// ── Do ──────────────────────────────────────────────────────────
-export { Do, DoAsync } from './do.js';
+// ── Attempt ─────────────────────────────────────────────────────
+export { attempt } from './attempt.js';
 //# sourceMappingURL=index.js.map

package/dist/unthrow/try.async.js

@@ -104,9 +104,9 @@ export class TryAsync {
     async *[Symbol.asyncIterator]() {
         const result = await this._promise;
         if (result.isErr()) {
-            // @ts-expect-error -- structurally equivalent, safe for DoAsync notation
+            // @ts-expect-error -- structurally equivalent, safe for attempt
             yield result;
-            throw new Error('Unreachable: DoAsync generator continued after Err yield');
+            throw new Error('Unreachable: attempt generator continued after Err yield');
         }
         return result.value;
     }

package/dist/unthrow/try.js

@@ -123,9 +123,9 @@ export class Err {
         return fn(this);
     }
     *[Symbol.iterator]() {
-        // @ts-expect-error -- structurally equivalent, safe for Do notation
+        // @ts-expect-error -- structurally equivalent, safe for attempt
         yield this;
-        throw new Error('Unreachable: Do notation generator continued after Err yield');
+        throw new Error('Unreachable: attempt generator continued after Err yield');
     }
 }
 export function ok(value) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clutchit",
-  "version": "0.0.14",
-  "description": "Resilience primitives for TypeScript — typed errors, retry, timeout, circuit breaking, scheduling, concurrency, and queues.",
+  "version": "0.0.16",
+  "description": "Resilience primitives for TypeScript",
   "keywords": [
     "typescript",
     "resilience",

package/dist/unthrow/do.d.ts

@@ -1,9 +0,0 @@
-import { type Try, Err } from './try.js';
-import { TryAsync } from './try.async.js';
-type InferFault<Y> = Y extends Err<never, infer E> ? E : never;
-export declare function Do<T, Y extends Err<never, any>>(generator: () => Generator<Y, T>): Try<T, InferFault<Y>>;
-export declare function Do<C, T, Y extends Err<never, any>>(ctx: C, generator: (ctx: C) => Generator<Y, T>): Try<T, InferFault<Y>>;
-export declare function DoAsync<T, Y extends Err<never, any>>(generator: () => AsyncGenerator<Y, T>): TryAsync<T, InferFault<Y>>;
-export declare function DoAsync<C, T, Y extends Err<never, any>>(ctx: C, generator: (ctx: C) => AsyncGenerator<Y, T>): TryAsync<T, InferFault<Y>>;
-export {};
-//# sourceMappingURL=do.d.ts.map

package/dist/unthrow/do.js

@@ -1,27 +0,0 @@
-import { ok } from './try.js';
-import { TryAsync } from './try.async.js';
-export function Do(ctxOrGenerator, generator) {
-    const gen = typeof ctxOrGenerator === 'function'
-        ? ctxOrGenerator()
-        : generator(ctxOrGenerator);
-    const next = gen.next();
-    while (!next.done) {
-        // Each yielded value is an Err — short-circuit
-        return next.value;
-    }
-    return ok(next.value);
-}
-export function DoAsync(ctxOrGenerator, generator) {
-    return new TryAsync((async () => {
-        const gen = typeof ctxOrGenerator === 'function'
-            ? ctxOrGenerator()
-            : generator(ctxOrGenerator);
-        const next = await gen.next();
-        while (!next.done) {
-            // Each yielded value is an Err — short-circuit
-            return next.value;
-        }
-        return ok(next.value);
-    })());
-}
-//# sourceMappingURL=do.js.map