nalloc 0.1.0 → 0.2.0

package/src/__tests__/option.types.ts

@@ -32,7 +32,8 @@ assert<Equals<typeof noneValue, None>>;
 const optValue: Option<number> = Math.random() > 0 ? of(5) : none;
 if (isSome(optValue)) {
   assert<Equals<typeof optValue, Some<number>>>;
-  const directAccess: number = optValue;}
+  const _: number = optValue;
+}
 if (isNone(optValue)) {
   assert<Equals<typeof optValue, None>>;
 }

package/src/__tests__/result.ts

@@ -33,6 +33,8 @@ import {
   isOkAnd,
   isErrAnd,
   tryCatch,
+  wrap,
+  toThrowable,
   unwrapOrReturn,
   assertOk,
   assertErr,
@@ -46,8 +48,12 @@ import {
   filterErr,
   safeTry,
   safeTryAsync,
-  fromPromise
+  fromPromise,
+  fromSchema,
+  gen,
+  genAsync
 } from '../result.js';
+import type { StandardSchema } from '../result.js';
 import { ok, err, isOk, isErr, optionOf as optOf, none } from '../types.js';
 
 describe('Result', () => {
@@ -600,6 +606,63 @@ describe('Result', () => {
 
   });
 
+  describe('wrap', () => {
+    it('wraps a function that succeeds', () => {
+      const safeParse = wrap(JSON.parse);
+      const result = safeParse('{"a":1}');
+      expect(isOk(result)).toBe(true);
+      expect(unwrap(result)).toEqual({ a: 1 });
+    });
+
+    it('wraps a function that throws', () => {
+      const safeParse = wrap(JSON.parse);
+      const result = safeParse('invalid');
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBeInstanceOf(SyntaxError);
+    });
+
+    it('preserves multi-arg signatures', () => {
+      const safeSlice = wrap((s: string, start: number, end: number) => s.slice(start, end));
+      const result = safeSlice('hello', 1, 3);
+      expect(unwrap(result)).toBe('el');
+    });
+
+    it('uses onError mapper', () => {
+      const safeParse = wrap(JSON.parse, (e) => (e as Error).message);
+      const result = safeParse('invalid');
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toContain('JSON');
+    });
+  });
+
+  describe('toThrowable', () => {
+    it('returns Ok value for successful Result', () => {
+      const fn = (x: number) => ok(x * 2);
+      const throwing = toThrowable(fn);
+      expect(throwing(5)).toBe(10);
+    });
+
+    it('throws Err error for failed Result', () => {
+      const fn = (x: number) => x > 0 ? ok(x) : err('negative');
+      const throwing = toThrowable(fn);
+      expect(() => throwing(-1)).toThrow('negative');
+    });
+
+    it('throws Error instances directly', () => {
+      const fn = () => err(new TypeError('bad type'));
+      const throwing = toThrowable(fn);
+      expect(() => throwing()).toThrow(TypeError);
+    });
+
+    it('round-trips with wrap', () => {
+      const original = JSON.parse;
+      const safe = wrap(original);
+      const restored = toThrowable(safe);
+      expect(restored('{"a":1}')).toEqual({ a: 1 });
+      expect(() => restored('invalid')).toThrow(SyntaxError);
+    });
+  });
+
   describe('control helpers', () => {
     it('unwrapOrReturn returns value for Ok', () => {
       const value = unwrapOrReturn(ok(42), () => 'fallback');
@@ -788,6 +851,16 @@ describe('Result', () => {
       expect(await result).toEqual([[1, 2], ['a']]);
     });
 
+    it('preserves input order with interleaved sync/async', async () => {
+      const result = await partitionMaybePromise([
+        Promise.resolve(ok(1)),
+        ok(2),
+        Promise.resolve(err('a')),
+        err('b'),
+      ]);
+      expect(result).toEqual([[1, 2], ['a', 'b']]);
+    });
+
     it('handles all async values', async () => {
       const result = await partitionMaybePromise([
         Promise.resolve(ok(1)),
@@ -949,4 +1022,124 @@ describe('Result', () => {
     });
   });
 
+  describe('fromSchema', () => {
+    const validSchema: StandardSchema<string> = {
+      '~standard': {
+        validate: (value) => typeof value === 'string'
+          ? { value }
+          : { issues: [{ message: 'Expected string' }] },
+      },
+    };
+
+    const asyncSchema: StandardSchema<number> = {
+      '~standard': {
+        validate: (value) => Promise.resolve(
+          typeof value === 'number'
+            ? { value }
+            : { issues: [{ message: 'Expected number' }] },
+        ),
+      },
+    };
+
+    it('returns Ok for valid sync schema', () => {
+      const result = fromSchema(validSchema, 'hello');
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe('hello');
+    });
+
+    it('returns Err with issues for invalid sync schema', () => {
+      const result = fromSchema(validSchema, 42);
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toEqual([{ message: 'Expected string' }]);
+    });
+
+    it('returns Ok for valid async schema', async () => {
+      const result = await fromSchema(asyncSchema, 42);
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(42);
+    });
+
+    it('returns Err for invalid async schema', async () => {
+      const result = await fromSchema(asyncSchema, 'hello');
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toEqual([{ message: 'Expected number' }]);
+    });
+  });
+
+  describe('gen', () => {
+    it('returns Ok for successful execution', () => {
+      const result = gen(function*($) {
+        const a = yield* $(ok(10));
+        const b = yield* $(ok(5));
+        return a + b;
+      });
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(15);
+    });
+
+    it('short-circuits on first Err', () => {
+      const result = gen(function*($) {
+        const a = yield* $(ok(10));
+        const b = yield* $(err('fail') as Result<number, string>);
+        const c = yield* $(ok(5));
+        return a + b + c;
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('fail');
+    });
+
+    it('propagates Err through chain', () => {
+      const parse = (s: string) => s === 'bad' ? err('parse error') : ok(Number(s));
+      const result = gen(function*($) {
+        const a = yield* $(parse('10'));
+        const b = yield* $(parse('bad'));
+        const c = yield* $(parse('5'));
+        return a + b + c;
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('parse error');
+    });
+
+    it('returns Ok for empty generator', () => {
+      const result = gen(function*() {
+        return 42;
+      });
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(42);
+    });
+  });
+
+  describe('genAsync', () => {
+    it('returns Ok for successful async execution', async () => {
+      const result = await genAsync(async function*($) {
+        const a = yield* $(ok(10));
+        const b = yield* $(await fromPromise(Promise.resolve(5)));
+        return a + b;
+      });
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(15);
+    });
+
+    it('short-circuits on first Err', async () => {
+      const result = await genAsync(async function*($) {
+        const a = yield* $(ok(10));
+        const b = yield* $(err('async fail') as Result<number, string>);
+        return a + b;
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('async fail');
+    });
+
+    it('handles rejected promises via fromPromise', async () => {
+      const result = await genAsync(async function*($) {
+        const a = yield* $(await fromPromise(Promise.resolve(10)));
+        const b = yield* $(await fromPromise(Promise.reject('boom')));
+        return a + b;
+      });
+      expect(isErr(result)).toBe(true);
+      expect((result as any).error).toBe('boom');
+    });
+  });
+
 });
+

package/src/__tests__/result.types.ts

@@ -6,12 +6,8 @@ import {
   mapErr,
   flatMap,
   bimap,
-  unwrap,
-  unwrapErr,
   unwrapOr,
   unwrapOrElse,
-  expect,
-  expectErr,
   and,
   or,
   orElse,
@@ -165,6 +161,12 @@ const tryResultTyped = of(() => {
 });
 assert<Equals<typeof tryResultTyped, Result<number, unknown>>>;
 
+const tryResultResult= of(() => {
+  if (Math.random() > 0.5) err("error");
+  return 42;
+});
+assert<Equals<typeof tryResultResult, Result<number, unknown>>>;
+
 
 const unwrapOrResult = unwrapOr(err<string>("error") as Result<number, string>, 42);
 assert<Equals<typeof unwrapOrResult, number>>;
@@ -205,6 +207,17 @@ const tryCatchTyped = tryCatch<number, string>(() => {
 }, error => (error as Error).message);
 assert<Equals<typeof tryCatchTyped, Result<number, string>>>;
 
+const tryCatchPassthroughErr = tryCatch(() => err('payload'));
+assert<Equals<typeof tryCatchPassthroughErr, Err<unknown>>>;
+
+const tryCatchPassthroughResult = tryCatch(() => Math.random() > 0.5 ? ok(1) : err('fail'));
+assert<Equals<typeof tryCatchPassthroughResult, Result<1, unknown>>>;
+
+const tryCatchPassthroughErrTyped = tryCatch(
+  () => err('payload'),
+  () => 0,
+);
+assert<Equals<typeof tryCatchPassthroughErrTyped, Err<string | number>>>;
 
 const unwrapFallback = unwrapOrReturn(ok(1) as Result<number, string>, () => 'fallback');
 assert<Equals<typeof unwrapFallback, number | 'fallback'>>;

package/src/iter.ts

@@ -1,6 +1,8 @@
 import { isSome, isErr, err as ERR } from './types.js';
 import type { Option, Result, Ok } from './types.js';
 
+const ITER_DONE: IteratorResult<never> = Object.freeze({ value: undefined as never, done: true as const });
+
 /**
  * Yields mapped values while the mapping function returns Some, stops at the first None.
  * @param source - The iterable to map over
@@ -42,7 +44,7 @@ export function safeIter<T>(source: Iterable<T>): IterableIterator<Result<T, unk
       return this;
     },
     next(): IteratorResult<Result<T, unknown>> {
-      if (done) return { value: undefined, done: true };
+      if (done) return ITER_DONE;
       try {
         const next = iter.next();
         if (next.done) {
@@ -64,7 +66,7 @@ export function safeIter<T>(source: Iterable<T>): IterableIterator<Result<T, unk
           // suppressed
         }
       }
-      return { value: undefined, done: true };
+      return ITER_DONE;
     },
   };
 }

package/src/option.ts

@@ -4,6 +4,8 @@ import type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen }
 export type { Some, None, Option };
 export { isSome, isNone, of };
 
+const NONE_PAIR: readonly [None, None] = Object.freeze([NONE, NONE]);
+
 /**
  * Creates an Option from a nullable value with widened types.
  * @param value - The value to wrap
@@ -178,6 +180,24 @@ export function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {
   return opt;
 }
 
+/**
+ * Executes a side effect if None, then returns the original Option.
+ * @param opt - The Option to tap
+ * @param fn - Side effect function
+ * @returns The original Option unchanged
+ * @example
+ * tapNone(none, () => console.log('missing')) // logs 'missing', returns None
+ */
+export function tapNone<T>(opt: Some<T>, fn: () => void): Some<T>;
+export function tapNone(opt: None, fn: () => void): None;
+export function tapNone<T>(opt: Option<T>, fn: () => void): Option<T>;
+export function tapNone<T>(opt: Option<T>, fn: () => void): Option<T> {
+  if (isNone(opt)) {
+    fn();
+  }
+  return opt;
+}
+
 /**
  * Returns true if None, or if Some and predicate returns true.
  * @param opt - The Option to check
@@ -351,7 +371,7 @@ export function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {
  * unzip(none)           // [None, None]
  */
 export function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {
-  if (isNone(opt)) return [NONE, NONE];
+  if (isNone(opt)) return NONE_PAIR as [Option<T>, Option<U>];
   const [a, b] = opt;
   return [of(a), of(b)];
 }