nalloc 0.2.2 → 0.4.0

package/build/safe.js

@@ -3,6 +3,7 @@ export { safeTry, safeTryAsync, unwrap, gen, genAsync } from "./result.js";
 export * as Option from "./option.js";
 export * as Result from "./result.js";
 export * as Iter from "./iter.js";
+export * as NonEmpty from "./nonempty.js";
 export function pipe(a, ...fns) {
     let result = a;
     for(let i = 0; i < fns.length; i++){

package/build/safe.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\n\n/**\n * Threads a value through a sequence of unary functions, left to right.\n * @param value - The initial value\n * @param fns - Functions to apply in order\n * @returns The result of applying all functions\n * @example\n * pipe(\n *   Result.tryCatch(() => JSON.parse(input)),\n *   r => Result.flatMap(r, validate),\n *   r => Result.map(r, transform),\n * )\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(a: unknown, ...fns: ((v: unknown) => unknown)[]): unknown {\n  let result = a;\n  for (let i = 0; i < fns.length; i++) {\n    result = fns[i](result);\n  }\n  return result;\n}\n"],"names":["some","none","ok","err","isOk","isErr","isSome","isNone","isThenable","isSync","safeTry","safeTryAsync","unwrap","gen","genAsync","Option","Result","Iter","pipe","a","fns","result","i","length"],"mappings":"AAAA,SAASA,IAAI,EAAEC,IAAI,EAAEC,EAAE,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,MAAM,QAAQ,aAAa;AAiBlG,SAASC,OAAO,EAAEC,YAAY,EAAEC,MAAM,EAAEC,GAAG,EAAEC,QAAQ,QAAQ,cAAc;AAC3E,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,IAAI,MAAM,YAAY;AA0ClC,OAAO,SAASC,KAAKC,CAAU,EAAE,GAAGC,GAAgC;IAClE,IAAIC,SAASF;IACb,IAAK,IAAIG,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnCD,SAASD,GAAG,CAACE,EAAE,CAACD;IAClB;IACA,OAAOA;AACT"}
+{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  MaybePromise,\n} from './types.js';\nexport { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';\nexport type { NonEmptyArray, ReadonlyNonEmptyArray } from './nonempty.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\nexport * as NonEmpty from './nonempty.js';\n\n/**\n * Threads a value through a sequence of unary functions, left to right.\n * @param value - The initial value\n * @param fns - Functions to apply in order\n * @returns The result of applying all functions\n * @example\n * pipe(\n *   Result.tryCatch(() => JSON.parse(input)),\n *   r => Result.flatMap(r, validate),\n *   r => Result.map(r, transform),\n * )\n */\nexport function pipe<A>(a: A): A;\nexport function pipe<A, B>(a: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(a: unknown, ...fns: ((v: unknown) => unknown)[]): unknown {\n  let result = a;\n  for (let i = 0; i < fns.length; i++) {\n    result = fns[i](result);\n  }\n  return result;\n}\n"],"names":["some","none","ok","err","isOk","isErr","isSome","isNone","isThenable","isSync","safeTry","safeTryAsync","unwrap","gen","genAsync","Option","Result","Iter","NonEmpty","pipe","a","fns","result","i","length"],"mappings":"AAAA,SAASA,IAAI,EAAEC,IAAI,EAAEC,EAAE,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,MAAM,QAAQ,aAAa;AAiBlG,SAASC,OAAO,EAAEC,YAAY,EAAEC,MAAM,EAAEC,GAAG,EAAEC,QAAQ,QAAQ,cAAc;AAE3E,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,IAAI,MAAM,YAAY;AAClC,OAAO,KAAKC,QAAQ,MAAM,gBAAgB;AA0C1C,OAAO,SAASC,KAAKC,CAAU,EAAE,GAAGC,GAAgC;IAClE,IAAIC,SAASF;IACb,IAAK,IAAIG,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnCD,SAASD,GAAG,CAACE,EAAE,CAACD;IAClB;IACA,OAAOA;AACT"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nalloc",
   "description": "Rust-like Option and Result for TypeScript with near-zero allocations for extreme performance",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -35,6 +35,10 @@
       "require": "./build/iter.cjs",
       "import": "./build/iter.js"
     },
+    "./nonempty": {
+      "require": "./build/nonempty.cjs",
+      "import": "./build/nonempty.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -54,6 +58,8 @@
     "err",
     "some",
     "none",
+    "nonempty",
+    "non-empty-array",
     "unwrap",
     "rust",
     "typescript",
@@ -92,23 +98,21 @@
   },
   "homepage": "https://github.com/3axap4eHko/nalloc#readme",
   "devDependencies": {
-    "@eslint/js": "^10.0.1",
-    "@vitest/coverage-v8": "^4.1.2",
-    "eslint": "^10.2.0",
-    "eslint-plugin-prettier": "^5.5.5",
+    "@vitest/coverage-v8": "^4.1.7",
     "inop": "^0.9.0",
     "overtake": "^2.1.1",
-    "prettier": "^3.8.1",
+    "oxlint": "^1.67.0",
+    "prettier": "^3.8.3",
     "tsafe": "^1.8.12",
     "tslib": "^2.8.1",
-    "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.0",
-    "vitest": "^4.1.2"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
   },
   "scripts": {
     "check": "tsc --noEmit -p tsconfig.check.json",
     "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
-    "lint": "eslint .",
+    "lint": "oxlint",
+    "format": "prettier --check .",
     "test": "vitest run",
     "bench": "overtake benchmarks/* --pin-cores -w 1 --progress",
     "bench:save": "pnpm bench --save-baseline .bench-baseline.json",

package/src/__tests__/iter.ts

@@ -96,6 +96,24 @@ describe('Iter', () => {
       expect(returned).toBe(true);
     });
 
+    it('return() after exhaustion is a no-op', () => {
+      let returnCalls = 0;
+      const iter: Iterable<number> = {
+        [Symbol.iterator]: () => {
+          let i = 0;
+          return {
+            next() { return i++ < 1 ? { value: i, done: false } : { value: undefined as unknown as number, done: true }; },
+            return() { returnCalls++; return { value: undefined, done: true }; },
+          };
+        },
+      };
+      const gen = safeIter(iter);
+      expect([...gen]).toHaveLength(1);
+      const final = gen.return!(undefined as never);
+      expect(final.done).toBe(true);
+      expect(returnCalls).toBe(0);
+    });
+
     it('yields values then stops on throw', () => {
       function* twoThenThrow() {
         yield 1;

package/src/__tests__/nonempty.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { isNonEmpty, assertNonEmpty, fromArray } from '../nonempty.js';
+import { isSome, isNone } from '../types.js';
+
+describe('NonEmpty', () => {
+  describe('isNonEmpty', () => {
+    it('returns false for an empty array', () => {
+      expect(isNonEmpty([])).toBe(false);
+    });
+
+    it('returns true for a single-element array', () => {
+      expect(isNonEmpty([1])).toBe(true);
+    });
+
+    it('returns true for a multi-element array', () => {
+      expect(isNonEmpty([1, 2, 3])).toBe(true);
+    });
+  });
+
+  describe('assertNonEmpty', () => {
+    it('throws on an empty array', () => {
+      expect(() => assertNonEmpty([])).toThrow('Expected array to be non-empty');
+    });
+
+    it('throws with a custom message', () => {
+      expect(() => assertNonEmpty([], 'nope')).toThrow('nope');
+    });
+
+    it('does not throw on a non-empty array', () => {
+      expect(() => assertNonEmpty([1])).not.toThrow();
+    });
+  });
+
+  describe('fromArray', () => {
+    it('returns None for an empty array', () => {
+      expect(isNone(fromArray([]))).toBe(true);
+    });
+
+    it('returns Some wrapping the same array value for a non-empty array', () => {
+      const input = [1, 2];
+      const result = fromArray(input);
+      expect(isSome(result)).toBe(true);
+      expect(result).toBe(input);
+    });
+  });
+});

package/src/__tests__/nonempty.types.ts

@@ -0,0 +1,38 @@
+import { assert, type Equals } from 'tsafe';
+import {
+  isNonEmpty,
+  assertNonEmpty,
+  fromArray,
+  type NonEmptyArray,
+  type ReadonlyNonEmptyArray,
+} from '../nonempty.js';
+import type { Option } from '../types.js';
+
+const readonlyValues: readonly number[] = [1, 2, 3];
+const mutableValues: number[] = [1, 2, 3];
+
+if (isNonEmpty(readonlyValues)) {
+  assert<Equals<typeof readonlyValues, ReadonlyNonEmptyArray<number>>>;
+  const _head: number = readonlyValues[0];
+}
+
+if (isNonEmpty(mutableValues)) {
+  const _head: number = mutableValues[0];
+}
+
+const asserted: readonly number[] = [1];
+assertNonEmpty(asserted);
+assert<Equals<typeof asserted, ReadonlyNonEmptyArray<number>>>;
+const _assertedHead: number = asserted[0];
+
+const maybeNonEmpty = fromArray<number>([1, 2]);
+assert<Equals<typeof maybeNonEmpty, Option<ReadonlyNonEmptyArray<number>>>>;
+
+const fromEmpty = fromArray([] as const);
+assert<Equals<typeof fromEmpty, Option<ReadonlyNonEmptyArray<never>>>>;
+
+type _MutableShape = Equals<NonEmptyArray<number>, [number, ...number[]]>;
+assert<_MutableShape>;
+
+type _ReadonlyShape = Equals<ReadonlyNonEmptyArray<number>, readonly [number, ...number[]]>;
+assert<_ReadonlyShape>;

package/src/__tests__/option.ts

@@ -426,6 +426,10 @@ describe('Option', () => {
     it('returns false for None', () => {
       expect(contains(none, 42)).toBe(false);
     });
+
+    it('treats NaN as equal to NaN', () => {
+      expect(contains(of(NaN), NaN)).toBe(true);
+    });
   });
 
   describe('isSomeAnd', () => {

package/src/__tests__/result.ts

@@ -748,12 +748,6 @@ describe('Result', () => {
       expect(isOk(outcome)).toBe(true);
       expect(unwrap(outcome)).toBe(3);
     });
-
-    it('any returns empty errors for empty array', () => {
-      const outcome = any([]);
-      expect(isErr(outcome)).toBe(true);
-      expect((outcome as any).error).toEqual([]);
-    });
   });
 
   describe('tryCatchMaybePromise', () => {
@@ -1107,6 +1101,22 @@ describe('Result', () => {
       expect(isOk(result)).toBe(true);
       expect(result).toBe(42);
     });
+
+    it('runs try/finally cleanup when short-circuiting on Err', () => {
+      let cleanedUp = false;
+      const result = gen(function*($) {
+        try {
+          const a = yield* $(ok(10));
+          const b = yield* $(err('fail') as Result<number, string>);
+          return a + b;
+        } finally {
+          cleanedUp = true;
+        }
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('fail');
+      expect(cleanedUp).toBe(true);
+    });
   });
 
   describe('genAsync', () => {
@@ -1139,6 +1149,22 @@ describe('Result', () => {
       expect(isErr(result)).toBe(true);
       expect((result as any).error).toBe('boom');
     });
+
+    it('runs try/finally cleanup when short-circuiting on Err', async () => {
+      let cleanedUp = false;
+      const result = await genAsync(async function*($) {
+        try {
+          const a = yield* $(ok(10));
+          const b = yield* $(err('async fail') as Result<number, string>);
+          return a + b;
+        } finally {
+          cleanedUp = true;
+        }
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('async fail');
+      expect(cleanedUp).toBe(true);
+    });
   });
 
 });

package/src/__tests__/result.types.ts

@@ -138,7 +138,7 @@ const collected = collect(results);
 assert<Equals<typeof collected, Result<number[], string>>>;
 
 const collectedAll = collectAll(results);
-assert<Equals<typeof collectedAll, Result<number[], string[]>>>;
+assert<Equals<typeof collectedAll, Result<number[], [string, ...string[]]>>>;
 
 const transposed = transpose(ok(42 as Option<number>) as Result<Option<number>, string>);
 assert<Equals<typeof transposed, Option<Result<number, string>>>>;
@@ -234,7 +234,7 @@ const allResult = all([ok(1), ok(2)]);
 assert<Equals<typeof allResult, Result<readonly number[], unknown>>>;
 
 const anyResult = any([err('a'), ok(3)]);
-assert<Equals<typeof anyResult, Result<number, string[]>>>;
+assert<Equals<typeof anyResult, Result<number, [string, ...string[]]>>>;
 
 const partitionAsyncResult = partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))]);
 assert<Equals<typeof partitionAsyncResult, Promise<[number[], string[]]>>>;

package/src/nonempty.ts

@@ -0,0 +1,48 @@
+import { NONE } from './types.js';
+import type { Option, Some } from './types.js';
+
+/** An array proven to contain at least one element. The runtime value is a plain array. */
+export type NonEmptyArray<T> = [T, ...T[]];
+
+/** A readonly array proven to contain at least one element. The runtime value is a plain array. */
+export type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
+
+/**
+ * Checks whether an array has at least one element.
+ * @param values - The array to check
+ * @returns true if the array is non-empty
+ * @example
+ * isNonEmpty([])     // false
+ * isNonEmpty([1])    // true
+ */
+export function isNonEmpty<T>(values: readonly T[]): values is ReadonlyNonEmptyArray<T> {
+  return values.length > 0;
+}
+
+/**
+ * Asserts that an array is non-empty, throwing otherwise.
+ * @param values - The array to check
+ * @param message - Custom error message
+ * @throws Error if the array is empty
+ * @example
+ * assertNonEmpty([1]) // passes
+ * assertNonEmpty([])  // throws Error
+ */
+export function assertNonEmpty<T>(values: readonly T[], message?: string): asserts values is ReadonlyNonEmptyArray<T> {
+  if (values.length === 0) {
+    throw new Error(message ?? 'Expected array to be non-empty');
+  }
+}
+
+/**
+ * Converts an array to an Option of a non-empty array. Returns the same array
+ * value when non-empty - no allocation or cloning.
+ * @param values - The array to convert
+ * @returns Some(values) typed as non-empty if length > 0, None otherwise
+ * @example
+ * fromArray([])     // None
+ * fromArray([1, 2]) // Some([1, 2]) with non-empty type
+ */
+export function fromArray<T>(values: readonly T[]): Option<ReadonlyNonEmptyArray<T>> {
+  return values.length > 0 ? (values as Some<ReadonlyNonEmptyArray<T>>) : NONE;
+}

package/src/option.ts

@@ -77,15 +77,14 @@ export function assertSome<T>(opt: Option<T>, message?: string): asserts opt is
  * runtime to preserve zero-allocation semantics. Use assertSome() if you
  * need runtime validation that a value is Some.
  *
- * @param _ - The value to assert as Option (not validated at runtime)
+ * @param value - The value to assert as Option (not validated at runtime)
  * @example
  * const value: number | null = getValue();
  * satisfiesOption(value); // Compiles, but no runtime check
  * // value is now typed as Option<number>
  */
-export function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {
-  // Compile-time only - no runtime validation to preserve zero-allocation semantics.
-}
+// oxlint-disable-next-line no-unused-vars
+export function satisfiesOption<T>(value: Option<T> | T): asserts value is Option<T> {}
 
 /**
  * Maps and filters an iterable, collecting only Some values.

package/src/result.ts

@@ -1,5 +1,6 @@
 import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf, isThenable } from './types.js';
 import type { Ok, Err, Result, Option, Widen, WidenNever, MaybePromise } from './types.js';
+import type { NonEmptyArray } from './nonempty.js';
 
 export type { Ok, Err, Result };
 export { isOk, isErr };
@@ -659,7 +660,7 @@ export function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {
  * collectAll([ok(1), ok(2)])           // Ok([1, 2])
  * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])
  */
-export function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {
+export function collectAll<T, E>(results: Result<T, E>[]): Result<T[], NonEmptyArray<E>> {
   const oks: T[] = [];
   const errs: E[] = [];
   for (let i = 0; i < results.length; i++) {
@@ -670,7 +671,7 @@ export function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {
       errs.push(result.error);
     }
   }
-  return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);
+  return errs.length > 0 ? ERR(errs as NonEmptyArray<E>) : (oks as Ok<T[]>);
 }
 
 /**
@@ -690,14 +691,14 @@ export function all<T, E>(results: Result<T, E>[]): Result<readonly Widen<T>[],
  * any([err('a'), ok(1), err('b')]) // Ok(1)
  * any([err('a'), err('b')])        // Err(['a', 'b'])
  */
-export function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]> {
+export function any<T, E>(results: NonEmptyArray<Result<T, E>>): Result<Widen<T>, NonEmptyArray<WidenNever<E>>> {
   const errors: WidenNever<E>[] = [];
   for (let i = 0; i < results.length; i++) {
     const result = results[i];
     if (isOk(result)) return result as Ok<Widen<T>>;
     errors.push((result as Err<WidenNever<E>>).error);
   }
-  return ERR(errors);
+  return ERR(errors as NonEmptyArray<WidenNever<E>>);
 }
 
 /**
@@ -711,7 +712,7 @@ export function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<
  */
 export function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {
   if (isErr(result)) {
-    return ERR(result.error) as Option<Result<T, E>>;
+    return result as Option<Result<T, E>>;
   }
   const opt = result as Option<T>;
   return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);
@@ -909,11 +910,8 @@ export async function safeTryAsync<T>(fn: () => Promise<T>): Promise<Result<T, u
 }
 
 function* unwrapYield<T, E>(result: Result<T, E>): Generator<Err<E>, T> {
-  if (isErr(result)) {
-    yield result;
-    return undefined as never;
-  }
-  return result;
+  if (isErr(result)) yield result;
+  return result as T;
 }
 
 type Unwrapper = <T, E>(result: Result<T, E>) => Generator<Err<E>, T>;
@@ -934,7 +932,11 @@ type Unwrapper = <T, E>(result: Result<T, E>) => Generator<Err<E>, T>;
 export function gen<E, T>(fn: ($: Unwrapper) => Generator<Err<E>, T>): Result<T, E> {
   const iter = fn(unwrapYield);
   const step = iter.next();
-  if (!step.done) return step.value;
+  if (!step.done) {
+    // short-circuit abandons the generator mid-body; resume it so try/finally cleanup runs
+    iter.return(undefined as never);
+    return step.value;
+  }
   return step.value as Ok<T>;
 }
 
@@ -952,6 +954,10 @@ export function gen<E, T>(fn: ($: Unwrapper) => Generator<Err<E>, T>): Result<T,
 export async function genAsync<E, T>(fn: ($: Unwrapper) => AsyncGenerator<Err<E>, T>): Promise<Result<T, E>> {
   const iter = fn(unwrapYield);
   const step = await iter.next();
-  if (!step.done) return step.value;
+  if (!step.done) {
+    // short-circuit abandons the generator mid-body; resume it so try/finally cleanup runs
+    await iter.return(undefined as never);
+    return step.value;
+  }
   return step.value as Ok<T>;
 }

package/src/safe.ts

@@ -16,9 +16,11 @@ export type {
   MaybePromise,
 } from './types.js';
 export { safeTry, safeTryAsync, unwrap, gen, genAsync } from './result.js';
+export type { NonEmptyArray, ReadonlyNonEmptyArray } from './nonempty.js';
 export * as Option from './option.js';
 export * as Result from './result.js';
 export * as Iter from './iter.js';
+export * as NonEmpty from './nonempty.js';
 
 /**
  * Threads a value through a sequence of unary functions, left to right.