nalloc 0.0.1 → 0.0.2

package/src/__tests__/result.ts

@@ -1,7 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import {
   of,
-  ofAsync,
   isSomeErr,
   map,
   mapErr,
@@ -34,20 +33,21 @@ import {
   isOkAnd,
   isErrAnd,
   tryCatch,
-  tryAsync,
-  fromPromise,
-  mapAsync,
-  andThenAsync,
-  matchAsync,
   unwrapOrReturn,
   assertOk,
   assertErr,
   all,
   any,
-  partitionAsync
+  partitionAsync,
+  tryCatchMaybePromise,
+  settleMaybePromise,
+  partitionMaybePromise,
+  filterOk,
+  filterErr,
+  safeTry,
+  safeTryAsync
 } from '../result.js';
 import { ok, err, isOk, isErr, optionOf as optOf, none } from '../types.js';
-import { formatResult, inspectResult } from '../devtools.js';
 
 describe('Result', () => {
   describe('constructors', () => {
@@ -57,10 +57,9 @@ describe('Result', () => {
       expect(result).toBe(42);
     });
 
-    it('ok does not throw when passed an Err', () => {
+    it('ok throws when passed an Err', () => {
       const error = err('test error');
-      expect(() => ok(error)).not.toThrow();
-      expect(isErr(ok(error))).toBe(true);
+      expect(() => ok(error)).toThrow('ok() cannot wrap an Err value');
     });
 
     it('err creates Err result', () => {
@@ -81,17 +80,6 @@ describe('Result', () => {
       expect((failure as any).error.message).toBe('failed');
     });
 
-    it('ofAsync catches async errors', async () => {
-      const success = await ofAsync(async () => 42);
-      expect(isOk(success)).toBe(true);
-      expect(unwrap(success)).toBe(42);
-
-      const failure = await ofAsync(async () => {
-        throw new Error('async failed');
-      });
-      expect(isErr(failure)).toBe(true);
-      expect((failure as any).error.message).toBe('async failed');
-    });
   });
 
   describe('type guards', () => {
@@ -249,8 +237,11 @@ describe('Result', () => {
       expect(unwrap(ok(42))).toBe(42);
     });
 
-    it('throws for Err', () => {
-      expect(() => unwrap(err('error'))).toThrow('Called unwrap on Err: error');
+    it('throws error value for Err', () => {
+      const e = err('error');
+      let caught: unknown;
+      try { unwrap(e); } catch (x) { caught = x; }
+      expect(caught).toBe('error');
     });
   });
 
@@ -430,6 +421,12 @@ describe('Result', () => {
       expect(isErr(result)).toBe(true);
       expect((result as any).error).toBe('first');
     });
+
+    it('returns second Err when first is Ok', () => {
+      const result = zip(ok(1), err('second'));
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('second');
+    });
   });
 
   describe('zipWith', () => {
@@ -443,6 +440,12 @@ describe('Result', () => {
       expect(isErr(result)).toBe(true);
       expect((result as any).error).toBe('fail');
     });
+
+    it('returns Err from right when left is Ok', () => {
+      const result = zipWith(ok(2), err('right'), (a, b) => a + b);
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('right');
+    });
   });
 
   describe('flatten', () => {
@@ -594,70 +597,14 @@ describe('Result', () => {
       expect((result as any).error).toBe('boom');
     });
 
-    it('tryAsync maps async rejection', async () => {
-      const result = await tryAsync<number, string>(
-        async () => {
-          throw new Error('boom');
-        },
-        error => (error as Error).message,
-      );
-      expect(isErr(result)).toBe(true);
-      expect((result as any).error).toBe('boom');
-    });
-
-    it('fromPromise resolves to Ok', async () => {
-      const result = await fromPromise(Promise.resolve(5));
-      expect(isOk(result)).toBe(true);
-      expect(unwrap(result)).toBe(5);
-    });
-
-    it('fromPromise maps rejection', async () => {
-      const result = await fromPromise(
-        Promise.reject(new Error('fail')),
-        error => (error as Error).message.toUpperCase(),
-      );
-      expect(isErr(result)).toBe(true);
-      expect((result as any).error).toBe('FAIL');
-    });
   });
 
-  describe('async mapping', () => {
-    it('mapAsync maps Ok value', async () => {
-      const result = await mapAsync(ok(2), async value => value * 3);
-      expect(isOk(result)).toBe(true);
-      expect(unwrap(result)).toBe(6);
-    });
-
-    it('mapAsync returns Err unchanged', async () => {
-      const result = await mapAsync(err('nope'), async (value: number) => value * 3);
-      expect(isErr(result)).toBe(true);
-      expect((result as any).error).toBe('nope');
-    });
-
-    it('andThenAsync chains Ok value', async () => {
-      const result = await andThenAsync(ok(2), async value => ok(value * 4));
-      expect(isOk(result)).toBe(true);
-      expect(unwrap(result)).toBe(8);
-    });
-
-    it('matchAsync selects branch', async () => {
-      const okValue = await matchAsync(
-        ok(5),
-        async value => value * 2,
-        async () => 0,
-      );
-      expect(okValue).toBe(10);
-
-      const errValue = await matchAsync(
-        err('fail'),
-        async () => 0,
-        async error => error.length,
-      );
-      expect(errValue).toBe(4);
+  describe('control helpers', () => {
+    it('unwrapOrReturn returns value for Ok', () => {
+      const value = unwrapOrReturn(ok(42), () => 'fallback');
+      expect(value).toBe(42);
     });
-  });
 
-  describe('control helpers', () => {
     it('unwrapOrReturn returns fallback for Err', () => {
       const value = unwrapOrReturn(err('oops'), () => 'fallback');
       expect(value).toBe('fallback');
@@ -669,11 +616,19 @@ describe('Result', () => {
       expect(result.id).toBe(1);
     });
 
+    it('assertOk throws on Err with default message', () => {
+      expect(() => assertOk(err('fail'))).toThrow('Expected Ok result');
+    });
+
     it('assertErr narrows failure', () => {
       const result = err('oops');
       assertErr(result);
       expect(result.error).toBe('oops');
     });
+
+    it('assertErr throws on Ok with default message', () => {
+      expect(() => assertErr(ok(42))).toThrow('Expected Err result');
+    });
   });
 
   describe('collections', () => {
@@ -705,17 +660,257 @@ describe('Result', () => {
       expect(oks).toEqual([1, 2]);
       expect(errs).toEqual(['a']);
     });
+
+    it('partitionAsync handles rejected promises as errors', async () => {
+      const promises = [
+        Promise.resolve(ok(1)),
+        Promise.reject(new Error('rejected')),
+        Promise.resolve(ok(2)),
+      ];
+      const [oks, errs] = await partitionAsync(promises);
+      expect(oks).toEqual([1, 2]);
+      expect(errs).toHaveLength(1);
+      expect((errs[0] as Error).message).toBe('rejected');
+    });
+
+    it('any returns first Ok at start', () => {
+      const outcome = any([ok(1), err('a'), err('b')]);
+      expect(isOk(outcome)).toBe(true);
+      expect(unwrap(outcome)).toBe(1);
+    });
+
+    it('any returns first Ok at end', () => {
+      const outcome = any([err('a'), err('b'), ok(3)]);
+      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('introspection helpers', () => {
-    it('inspectResult exposes discriminated metadata', () => {
-      expect(inspectResult(ok(4))).toEqual({ status: 'ok', value: 4 });
-      expect(inspectResult(err('error'))).toEqual({ status: 'err', error: 'error' });
+  describe('tryCatchMaybePromise', () => {
+    it('returns Ok for sync success', () => {
+      const result = tryCatchMaybePromise(() => 42);
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(42);
     });
 
-    it('formatResult prints friendly string', () => {
-      expect(formatResult(ok(1))).toBe('Ok(1)');
-      expect(formatResult(err(new Error('boom')))).toBe('Err(boom)');
+    it('returns Err for sync throw', () => {
+      const result = tryCatchMaybePromise(() => {
+        throw new Error('sync error');
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error.message).toBe('sync error');
+    });
+
+    it('returns Ok for async success', async () => {
+      const result = await tryCatchMaybePromise(() => Promise.resolve(42));
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(42);
+    });
+
+    it('returns Err for async rejection', async () => {
+      const result = await tryCatchMaybePromise(() => Promise.reject(new Error('async error')));
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error.message).toBe('async error');
+    });
+
+    it('uses onError mapper for sync throw', () => {
+      const result = tryCatchMaybePromise(
+        () => { throw new Error('fail'); },
+        (e) => `mapped: ${(e as Error).message}`
+      );
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('mapped: fail');
+    });
+
+    it('uses onError mapper for async rejection', async () => {
+      const result = await tryCatchMaybePromise(
+        () => Promise.reject(new Error('fail')),
+        (e) => `mapped: ${(e as Error).message}`
+      );
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('mapped: fail');
+    });
+  });
+
+  describe('settleMaybePromise', () => {
+    it('returns sync array for all sync values', () => {
+      const result = settleMaybePromise([1, 2, 3]);
+      expect(result).not.toBeInstanceOf(Promise);
+      expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('returns Promise for mixed sync/async values', async () => {
+      const result = settleMaybePromise([1, Promise.resolve(2), 3]);
+      expect(result).toBeInstanceOf(Promise);
+      expect(await result).toEqual([1, 2, 3]);
+    });
+
+    it('converts rejected promises to Err', async () => {
+      const result = await settleMaybePromise([1, Promise.reject('fail'), 3]);
+      expect(isOk(result[0])).toBe(true);
+      expect(isErr(result[1])).toBe(true);
+      expect((result[1] as any).error).toBe('fail');
+      expect(isOk(result[2])).toBe(true);
+    });
+
+    it('handles all async values', async () => {
+      const result = await settleMaybePromise([
+        Promise.resolve(1),
+        Promise.resolve(2)
+      ]);
+      expect(result).toEqual([1, 2]);
+    });
+
+    it('returns empty array for empty input', () => {
+      const result = settleMaybePromise([]);
+      expect(result).not.toBeInstanceOf(Promise);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('partitionMaybePromise', () => {
+    it('returns sync partition for all sync values', () => {
+      const result = partitionMaybePromise([ok(1), err('a'), ok(2)]);
+      expect(result).not.toBeInstanceOf(Promise);
+      expect(result).toEqual([[1, 2], ['a']]);
+    });
+
+    it('returns Promise for mixed sync/async values', async () => {
+      const result = partitionMaybePromise([ok(1), Promise.resolve(err('a')), ok(2)]);
+      expect(result).toBeInstanceOf(Promise);
+      expect(await result).toEqual([[1, 2], ['a']]);
+    });
+
+    it('handles all async values', async () => {
+      const result = await partitionMaybePromise([
+        Promise.resolve(ok(1)),
+        Promise.resolve(err('a'))
+      ]);
+      expect(result).toEqual([[1], ['a']]);
+    });
+
+    it('handles rejected promises as errors', async () => {
+      const result = await partitionMaybePromise([
+        ok(1),
+        Promise.reject(new Error('rejected'))
+      ]);
+      expect(result[0]).toEqual([1]);
+      expect(result[1]).toHaveLength(1);
+      expect((result[1][0] as Error).message).toBe('rejected');
+    });
+
+    it('returns empty arrays for empty input', () => {
+      const result = partitionMaybePromise([]);
+      expect(result).not.toBeInstanceOf(Promise);
+      expect(result).toEqual([[], []]);
+    });
+  });
+
+  describe('filterOk', () => {
+    it('extracts Ok values', () => {
+      expect(filterOk([ok(1), err('a'), ok(2)])).toEqual([1, 2]);
+    });
+
+    it('returns empty for all Err', () => {
+      expect(filterOk([err('a'), err('b')])).toEqual([]);
+    });
+
+    it('returns empty for empty input', () => {
+      expect(filterOk([])).toEqual([]);
     });
   });
+
+  describe('filterErr', () => {
+    it('extracts Err values', () => {
+      expect(filterErr([ok(1), err('a'), ok(2), err('b')])).toEqual(['a', 'b']);
+    });
+
+    it('returns empty for all Ok', () => {
+      expect(filterErr([ok(1), ok(2)])).toEqual([]);
+    });
+
+    it('returns empty for empty input', () => {
+      expect(filterErr([])).toEqual([]);
+    });
+  });
+
+  describe('safeTry', () => {
+    it('returns Ok for successful execution', () => {
+      const result = safeTry(() => {
+        const a = unwrap(ok(10));
+        const b = unwrap(ok(5));
+        return a + b;
+      });
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(15);
+    });
+
+    it('returns Err when unwrap throws', () => {
+      const e = err('failed');
+      const result = safeTry(() => {
+        unwrap(e);
+        return 42;
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('failed');
+    });
+
+    it('catches regular errors', () => {
+      const result = safeTry(() => {
+        throw new Error('boom');
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: Error }).error.message).toBe('boom');
+    });
+
+    it('propagates Err through chain', () => {
+      const parse = (s: string) => s === 'bad' ? err('parse error') : ok(Number(s));
+      const result = safeTry(() => {
+        const a = unwrap(parse('10'));
+        const b = unwrap(parse('bad'));
+        const c = unwrap(parse('5'));
+        return a + b + c;
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('parse error');
+    });
+  });
+
+  describe('safeTryAsync', () => {
+    it('returns Ok for successful async execution', async () => {
+      const result = await safeTryAsync(async () => {
+        const a = unwrap(ok(10));
+        const b = unwrap(await Promise.resolve(ok(5)));
+        return a + b;
+      });
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(15);
+    });
+
+    it('returns Err when unwrap throws in async', async () => {
+      const e = err('async failed');
+      const result = await safeTryAsync(async () => {
+        unwrap(e);
+        return 42;
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('async failed');
+    });
+
+    it('catches rejected promises', async () => {
+      const result = await safeTryAsync(async () => {
+        await Promise.reject(new Error('rejected'));
+        return 42;
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: Error }).error.message).toBe('rejected');
+    });
+  });
+
 });

package/src/__tests__/result.types.ts

@@ -24,10 +24,7 @@ import {
   isOkAnd,
   isErrAnd,
   of,
-  ofAsync,
   tryCatch,
-  tryAsync,
-  fromPromise,
   unwrapOrReturn,
   assertOk,
   assertErr,
@@ -162,17 +159,11 @@ const tryResult = of(() => {
 });
 assert<Equals<typeof tryResult, Result<number, unknown>>>;
 
-const tryResultTyped = of<number, Error>(() => {
+const tryResultTyped = of(() => {
   if (Math.random() > 0.5) throw new Error("oops");
   return 42;
 });
-assert<Equals<typeof tryResultTyped, Result<number, Error>>>;
-
-const asyncResult = ofAsync<number>(async () => {
-  return 42;
-});
-assert<Equals<typeof asyncResult, Promise<Result<number, unknown>>>>;
-
+assert<Equals<typeof tryResultTyped, Result<number, unknown>>>;
 
 
 const unwrapOrResult = unwrapOr(err<string>("error") as Result<number, string>, 42);
@@ -214,16 +205,6 @@ const tryCatchTyped = tryCatch<number, string>(() => {
 }, error => (error as Error).message);
 assert<Equals<typeof tryCatchTyped, Result<number, string>>>;
 
-const tryAsyncResult = tryAsync(async () => 1);
-assert<Equals<typeof tryAsyncResult, Promise<Result<number, unknown>>>>;
-
-const tryAsyncTyped = tryAsync<number, string>(async () => {
-  throw new Error('boom');
-}, error => (error as Error).message);
-assert<Equals<typeof tryAsyncTyped, Promise<Result<number, string>>>>;
-
-const fromPromiseResult = fromPromise(Promise.resolve(1));
-assert<Equals<typeof fromPromiseResult, Promise<Result<number, unknown>>>>;
 
 const unwrapFallback = unwrapOrReturn(ok(1) as Result<number, string>, () => 'fallback');
 assert<Equals<typeof unwrapFallback, number | string>>;
@@ -237,7 +218,7 @@ assertErr(maybeErr);
 const narrowedErr: Err<string> = maybeErr;
 
 const allResult = all([ok(1), ok(2)]);
-assert<Equals<typeof allResult, Result<number[], unknown>>>;
+assert<Equals<typeof allResult, Result<readonly number[], unknown>>>;
 
 const anyResult = any([err('a'), ok(3)]);
 assert<Equals<typeof anyResult, Result<number, string[]>>>;

package/src/__tests__/safe.ts

@@ -1,24 +1,18 @@
 import { describe, it, expect } from 'vitest';
-import * as safe from '../safe.js';
-import { err } from '../types.js';
+import { ok, some, err, isSome } from '../types.js';
 
-describe('nalloc/safe exports', () => {
-  it('exports match nalloc', () => {
-    expect(safe.some).toBeDefined();
-    expect('none' in safe).toBe(true);
-    expect(safe.ok).toBeDefined();
-    expect(safe.err).toBeDefined();
-    expect(safe.Option).toBeDefined();
-    expect(safe.Result).toBeDefined();
+describe('safe constructors', () => {
+  it('some validates non-nullable input', () => {
+    expect(isSome(some(42))).toBe(true);
   });
 
-  it('safe some throws on null/undefined', () => {
-    expect(() => safe.some(null as any)).toThrow();
-    expect(() => safe.some(undefined as any)).toThrow();
+  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('safe ok throws on Err', () => {
+  it('ok throws on Err', () => {
     const error = err('test');
-    expect(() => safe.ok(error)).toThrow();
+    expect(() => ok(error)).toThrow('ok() cannot wrap an Err value');
   });
 });

package/src/__tests__/unsafe.ts

@@ -1,24 +1,23 @@
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import * as unsafe from '../unsafe.js';
-import { err } from '../types.js';
+import { err, isErr, isNone } from '../types.js';
 
-describe('nalloc/unsafe exports', () => {
-  it('exports match nalloc', () => {
+describe('unsafe module', () => {
+  it('exports constructors', () => {
     expect(unsafe.some).toBeDefined();
-    expect('none' in unsafe).toBe(true);
     expect(unsafe.ok).toBeDefined();
-    expect(unsafe.err).toBeDefined();
-    expect(unsafe.Option).toBeDefined();
-    expect(unsafe.Result).toBeDefined();
   });
 
-  it('unsafe some does not throw on null/undefined', () => {
+  it('some does not validate nullish values', () => {
     expect(() => unsafe.some(null)).not.toThrow();
     expect(() => unsafe.some(undefined)).not.toThrow();
+    expect(isNone(unsafe.some(null))).toBe(true);
+    expect(isNone(unsafe.some(undefined))).toBe(true);
   });
 
-  it('unsafe ok does not throw on Err', () => {
-    const error = err('test');
-    expect(() => unsafe.ok(error)).not.toThrow();
+  it('ok does not validate Err payloads', () => {
+    const payload = err('unsafe payload');
+    expect(() => unsafe.ok(payload)).not.toThrow();
+    expect(isErr(unsafe.ok(payload))).toBe(true);
   });
 });

package/src/index.ts

@@ -1,18 +1 @@
-export { some, none, ok, err } from './types.js';
-export type {
-  Some,
-  None,
-  Ok,
-  Err,
-  Option as OptionType,
-  OptionValue,
-  IsOption,
-  InferSome,
-  Result as ResultType,
-  ResultValue,
-  ResultErrorType,
-  IsResult,
-  InferErr,
-} from './types.js';
-export * as Option from './option.js';
-export * as Result from './result.js';
+export * from './safe.js';