nalloc 0.0.1 → 0.0.2

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.0.1",
+  "version": "0.0.2",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -31,13 +31,9 @@
       "require": "./build/unsafe.cjs",
       "import": "./build/unsafe.js"
     },
-    "./testing": {
-      "require": "./build/testing.cjs",
-      "import": "./build/testing.js"
-    },
-    "./devtools": {
-      "require": "./build/devtools.cjs",
-      "import": "./build/devtools.js"
+    "./iter": {
+      "require": "./build/iter.cjs",
+      "import": "./build/iter.js"
     },
     "./package.json": "./package.json"
   },
@@ -71,17 +67,18 @@
   },
   "homepage": "https://github.com/3axap4eHko/nalloc#readme",
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@vitest/coverage-v8": "^4.0.16",
-    "eslint": "^9.39.2",
-    "eslint-plugin-prettier": "^5.5.4",
-    "inop": "^0.8.10",
-    "prettier": "^3.7.4",
+    "@eslint/js": "^10.0.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.2",
+    "eslint-plugin-prettier": "^5.5.5",
+    "inop": "^0.9.0",
+    "overtake": "^1.4.0",
+    "prettier": "^3.8.1",
     "tsafe": "^1.8.12",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.52.0",
-    "vitest": "^4.0.16"
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "check": "tsc src/__tests__/option.types.ts src/__tests__/result.types.ts --noEmit --lib esnext,dom --target esnext --module nodenext --moduleResolution nodenext",

package/src/__tests__/index.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import * as index from '../index.js';
+import { isThenable, isSync } from '../types.js';
 
 describe('index.ts exports', () => {
   it('exports exist', () => {
@@ -10,4 +11,45 @@ describe('index.ts exports', () => {
     expect(index.Option).toBeDefined();
     expect(index.Result).toBeDefined();
   });
+});
+
+describe('MaybePromise guards', () => {
+  describe('isThenable', () => {
+    it('returns true for Promise', () => {
+      expect(isThenable(Promise.resolve(1))).toBe(true);
+    });
+
+    it('returns true for PromiseLike', () => {
+      const thenable = { then: (cb: (v: number) => void) => cb(1) };
+      expect(isThenable(thenable)).toBe(true);
+    });
+
+    it('returns false for plain value', () => {
+      expect(isThenable(42)).toBe(false);
+      expect(isThenable('string')).toBe(false);
+      expect(isThenable({ x: 1 })).toBe(false);
+    });
+
+    it('returns false for null/undefined', () => {
+      expect(isThenable(null)).toBe(false);
+      expect(isThenable(undefined)).toBe(false);
+    });
+  });
+
+  describe('isSync', () => {
+    it('returns false for Promise', () => {
+      expect(isSync(Promise.resolve(1))).toBe(false);
+    });
+
+    it('returns true for plain value', () => {
+      expect(isSync(42)).toBe(true);
+      expect(isSync('string')).toBe(true);
+      expect(isSync({ x: 1 })).toBe(true);
+    });
+
+    it('returns true for null/undefined', () => {
+      expect(isSync(null)).toBe(true);
+      expect(isSync(undefined)).toBe(true);
+    });
+  });
 });

package/src/__tests__/iter.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect } from 'vitest';
+import {
+  mapWhile,
+  safeIter,
+  tryCollect,
+  tryFold,
+  tryForEach,
+} from '../iter.js';
+import { ok, err, isOk, isErr, some, none } from '../types.js';
+import type { Result } from '../types.js';
+
+describe('Iter', () => {
+  describe('mapWhile', () => {
+    it('yields while Some, stops at first None', () => {
+      const result = [...mapWhile([1, 2, 3, 4, 5], n => n < 4 ? some(n * 10) : none)];
+      expect(result).toEqual([10, 20, 30]);
+    });
+
+    it('yields nothing when first is None', () => {
+      const result = [...mapWhile([1, 2, 3], () => none)];
+      expect(result).toEqual([]);
+    });
+
+    it('yields all when all Some', () => {
+      const result = [...mapWhile([1, 2, 3], n => some(n))];
+      expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('handles empty source', () => {
+      const result = [...mapWhile([], () => some(1))];
+      expect(result).toEqual([]);
+    });
+
+    it('does not call fn after first None', () => {
+      let calls = 0;
+      const result = [...mapWhile([1, 2, 3, 4], n => {
+        calls++;
+        return n <= 2 ? some(n) : none;
+      })];
+      expect(result).toEqual([1, 2]);
+      expect(calls).toBe(3);
+    });
+  });
+
+  describe('safeIter', () => {
+    it('wraps normal values as Ok', () => {
+      const results = [...safeIter([1, 2, 3])];
+      expect(results).toHaveLength(3);
+      expect(results.every(r => isOk(r))).toBe(true);
+      expect(results).toEqual([1, 2, 3]);
+    });
+
+    it('catches per-item throws as Err', () => {
+      function* throwing() {
+        yield 1;
+        throw new Error('boom');
+      }
+      const results = [...safeIter(throwing())];
+      expect(results).toHaveLength(2);
+      expect(isOk(results[0])).toBe(true);
+      expect(results[0]).toBe(1);
+      expect(isErr(results[1])).toBe(true);
+      expect((results[1] as { error: Error }).error.message).toBe('boom');
+    });
+
+    it('handles empty source', () => {
+      expect([...safeIter([])]).toEqual([]);
+    });
+
+    it('stops after first throw from a persistently throwing iterator', () => {
+      const iter: Iterable<number> = {
+        [Symbol.iterator]: () => ({
+          next() { throw new Error('always'); },
+        }),
+      };
+      const results = [...safeIter(iter)];
+      expect(results).toHaveLength(1);
+      expect(isErr(results[0])).toBe(true);
+      expect((results[0] as { error: Error }).error.message).toBe('always');
+    });
+
+    it('calls iter.return() when consumer breaks early', () => {
+      let returned = false;
+      const iter: Iterable<number> = {
+        [Symbol.iterator]: () => {
+          let i = 0;
+          return {
+            next() { return { value: ++i, done: false }; },
+            return() { returned = true; return { value: undefined, done: true }; },
+          };
+        },
+      };
+      const gen = safeIter(iter);
+      gen.next(); // consume one value
+      gen.return(undefined as any); // consumer breaks
+      expect(returned).toBe(true);
+    });
+
+    it('yields values then stops on throw', () => {
+      function* twoThenThrow() {
+        yield 1;
+        yield 2;
+        throw new Error('third');
+      }
+      const results = [...safeIter(twoThenThrow())];
+      expect(results).toHaveLength(3);
+      expect(isOk(results[0])).toBe(true);
+      expect(results[0]).toBe(1);
+      expect(isOk(results[1])).toBe(true);
+      expect(results[1]).toBe(2);
+      expect(isErr(results[2])).toBe(true);
+      expect((results[2] as { error: Error }).error.message).toBe('third');
+    });
+  });
+
+  describe('tryCollect', () => {
+    it('collects all Ok values into Result<T[], E>', () => {
+      const results: Result<number, string>[] = [ok(1), ok(2), ok(3)];
+      const collected = tryCollect(results);
+      expect(isOk(collected)).toBe(true);
+      expect(collected).toEqual([1, 2, 3]);
+    });
+
+    it('short-circuits on first Err', () => {
+      let calls = 0;
+      function* source(): Generator<Result<number, string>> {
+        calls++; yield ok(1);
+        calls++; yield err('fail');
+        calls++; yield ok(3);
+      }
+      const collected = tryCollect(source());
+      expect(isErr(collected)).toBe(true);
+      expect((collected as { error: string }).error).toBe('fail');
+      expect(calls).toBe(2);
+    });
+
+    it('handles empty source', () => {
+      const collected = tryCollect([]);
+      expect(isOk(collected)).toBe(true);
+      expect(collected).toEqual([]);
+    });
+
+    it('works with lazy generators', () => {
+      function* source(): Generator<Result<number, string>> {
+        yield ok(2);
+        yield ok(4);
+        yield ok(6);
+      }
+      const collected = tryCollect(source());
+      expect(isOk(collected)).toBe(true);
+      expect(collected).toEqual([2, 4, 6]);
+    });
+  });
+
+  describe('tryFold', () => {
+    it('folds all values when no error', () => {
+      const result = tryFold([1, 2, 3], 0, (acc, n) => ok(acc + n));
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(6);
+    });
+
+    it('short-circuits on first Err', () => {
+      let calls = 0;
+      const result = tryFold([1, 2, 3, 4], 0, (acc, n) => {
+        calls++;
+        return n === 3 ? err('stopped') as Result<number, string> : ok(acc + n);
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('stopped');
+      expect(calls).toBe(3);
+    });
+
+    it('handles empty source', () => {
+      const result = tryFold([], 42, () => ok(0));
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(42);
+    });
+  });
+
+  describe('tryForEach', () => {
+    it('iterates all items when no error', () => {
+      const seen: number[] = [];
+      const result = tryForEach([1, 2, 3], n => {
+        seen.push(n);
+        return ok(undefined);
+      });
+      expect(isOk(result)).toBe(true);
+      expect(seen).toEqual([1, 2, 3]);
+    });
+
+    it('short-circuits on first Err', () => {
+      const seen: number[] = [];
+      const result = tryForEach([1, 2, 3, 4], n => {
+        seen.push(n);
+        return n === 2 ? err('stop') as Result<void, string> : ok(undefined);
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('stop');
+      expect(seen).toEqual([1, 2]);
+    });
+
+    it('handles empty source', () => {
+      const result = tryForEach([], () => ok(undefined));
+      expect(isOk(result)).toBe(true);
+    });
+  });
+
+  describe('composition', () => {
+    it('safeIter -> native filter(isOk) collects safe values', () => {
+      function* unstable() {
+        yield 1;
+        throw new Error('oops');
+      }
+      const safe = [...safeIter(unstable())].filter(isOk);
+      expect(safe).toEqual([1]);
+    });
+  });
+});

package/src/__tests__/option.ts

@@ -36,9 +36,10 @@ import {
   unwrapOrReturn,
   assertSome,
   satisfiesOption,
-  filterMap
+  filterMap,
+  isNoneOr,
+  findMap
 } from '../option.js';
-import { formatOption, inspectOption } from '../devtools.js';
 import { ok, err, some, none } from '../types.js';
 
 describe('Option', () => {
@@ -65,11 +66,9 @@ describe('Option', () => {
       expect(opt).toBe(42);
     });
 
-    it('some does not throw on null/undefined', () => {
-      expect(() => some(null as any)).not.toThrow();
-      expect(() => some(undefined as any)).not.toThrow();
-      expect(isNone(some(null as any))).toBe(true);
-      expect(isNone(some(undefined as any))).toBe(true);
+    it('some throws on null/undefined', () => {
+      expect(() => some(null as any)).toThrow('some() requires a non-nullable value');
+      expect(() => some(undefined as any)).toThrow('some() requires a non-nullable value');
     });
 
     it('none creates None', () => {
@@ -564,9 +563,19 @@ describe('Option', () => {
       expect(isSome(opt)).toBe(true);
       expect(unwrap(opt)).toBe(99);
     });
+
+    it('fromPromise returns None on rejection without callback', async () => {
+      const opt = await fromPromise(Promise.reject(new Error('boom')));
+      expect(isNone(opt)).toBe(true);
+    });
   });
 
   describe('control helpers', () => {
+    it('unwrapOrReturn returns value for Some', () => {
+      const result = unwrapOrReturn(of(42), () => 77);
+      expect(result).toBe(42);
+    });
+
     it('unwrapOrReturn returns fallback for None', () => {
       const result = unwrapOrReturn(none, () => 77);
       expect(result).toBe(77);
@@ -588,18 +597,6 @@ describe('Option', () => {
     });
   });
 
-  describe('introspection helpers', () => {
-    it('inspectOption exposes discriminated metadata', () => {
-      expect(inspectOption(of(4))).toEqual({ kind: 'some', value: 4 });
-      expect(inspectOption(none)).toEqual({ kind: 'none' });
-    });
-
-    it('formatOption prints human friendly value', () => {
-      expect(formatOption(of(1))).toBe('Some(1)');
-      expect(formatOption(none)).toBe('None');
-    });
-  });
-
   describe('filterMap', () => {
     it('collects Some values from iterable', () => {
       const items = [of(1), none, of(3)];
@@ -607,4 +604,36 @@ describe('Option', () => {
       expect(result).toEqual([1, 3]);
     });
   });
+
+  describe('isNoneOr', () => {
+    it('returns true for None', () => {
+      expect(isNoneOr(none, () => false)).toBe(true);
+    });
+
+    it('returns true for Some when predicate is true', () => {
+      expect(isNoneOr(some(5), x => x > 2)).toBe(true);
+    });
+
+    it('returns false for Some when predicate is false', () => {
+      expect(isNoneOr(some(1), x => x > 2)).toBe(false);
+    });
+  });
+
+  describe('findMap', () => {
+    it('returns first Some result', () => {
+      const result = findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none);
+      expect(isSome(result)).toBe(true);
+      expect(result).toBe(4);
+    });
+
+    it('returns None when no match', () => {
+      const result = findMap([1, 2, 3], n => n > 5 ? some(n) : none);
+      expect(isNone(result)).toBe(true);
+    });
+
+    it('returns None for empty iterable', () => {
+      const result = findMap([], () => some(1));
+      expect(isNone(result)).toBe(true);
+    });
+  });
 });