nalloc 0.1.0 → 0.2.1

package/build/safe.d.ts

@@ -1,6 +1,27 @@
 export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from './types.js';
 export type { Some, None, Ok, Err, Option as OptionType, OptionValue, IsOption, InferSome, Result as ResultType, ResultValue, ResultErrorType, IsResult, InferErr, MaybePromise, } from './types.js';
-export { safeTry, safeTryAsync, unwrap } from './result.js';
+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';
+/**
+ * Threads a value through a sequence of unary functions, left to right.
+ * @param value - The initial value
+ * @param fns - Functions to apply in order
+ * @returns The result of applying all functions
+ * @example
+ * pipe(
+ *   Result.tryCatch(() => JSON.parse(input)),
+ *   r => Result.flatMap(r, validate),
+ *   r => Result.map(r, transform),
+ * )
+ */
+export declare function pipe<A>(a: A): A;
+export declare function pipe<A, B>(a: A, ab: (a: A) => B): B;
+export declare function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+export declare function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+export declare 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;
+export declare 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;
+export declare 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;
+export declare function pipe<A, B, C, D, E, F, G, H>(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, gh: (g: G) => H): H;
+export declare function pipe<A, B, C, D, E, F, G, H, I>(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, gh: (g: G) => H, hi: (h: H) => I): I;

package/build/safe.js

@@ -1,7 +1,14 @@
 export { some, none, ok, err, isOk, isErr, isSome, isNone, isThenable, isSync } from "./types.js";
-export { safeTry, safeTryAsync, unwrap } from "./result.js";
+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 function pipe(a, ...fns) {
+    let result = a;
+    for(let i = 0; i < fns.length; i++){
+        result = fns[i](result);
+    }
+    return result;
+}
 
 //# sourceMappingURL=safe.js.map

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 } from './result.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\nexport * as Iter from './iter.js';\n"],"names":["some","none","ok","err","isOk","isErr","isSome","isNone","isThenable","isSync","safeTry","safeTryAsync","unwrap","Option","Result","Iter"],"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,QAAQ,cAAc;AAC5D,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,IAAI,MAAM,YAAY"}
+{"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"}

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.1.0",
+  "version": "0.2.1",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -102,7 +102,7 @@
     "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
     "lint": "eslint .",
     "test": "vitest run",
-    "bench": "overtake benchmarks/* --pin-cores -w 2 --progress",
+    "bench": "overtake benchmarks/* --pin-cores -w 1 --progress",
     "bench:save": "pnpm bench --save-baseline .bench-baseline.json",
     "bench:test": "pnpm bench --compare-baseline .bench-baseline.json"
   }

package/src/__tests__/index.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import * as index from '../index.js';
+import { pipe, Result } from '../index.js';
 import { isThenable, isSync } from '../types.js';
+import { ok, err } from '../types.js';
 
 describe('index.ts exports', () => {
   it('exports exist', () => {
@@ -52,4 +54,36 @@ describe('MaybePromise guards', () => {
       expect(isSync(undefined)).toBe(true);
     });
   });
+});
+
+describe('pipe', () => {
+  it('returns value with no functions', () => {
+    expect(pipe(42)).toBe(42);
+  });
+
+  it('applies single function', () => {
+    expect(pipe(2, x => x * 3)).toBe(6);
+  });
+
+  it('applies multiple functions left to right', () => {
+    expect(pipe(2, x => x * 3, x => x + 1, x => String(x))).toBe('7');
+  });
+
+  it('works with Result operations', () => {
+    const result = pipe(
+      Result.tryCatch(() => JSON.parse('{"a":1}')),
+      r => Result.map(r, (v: { a: number }) => v.a),
+      r => Result.unwrapOr(r, 0),
+    );
+    expect(result).toBe(1);
+  });
+
+  it('works with Result error path', () => {
+    const result = pipe(
+      Result.tryCatch(() => JSON.parse('invalid')),
+      r => Result.map(r, (v: unknown) => v),
+      r => Result.unwrapOr(r, 'fallback'),
+    );
+    expect(result).toBe('fallback');
+  });
 });

package/src/__tests__/option.ts

@@ -38,7 +38,8 @@ import {
   satisfiesOption,
   filterMap,
   isNoneOr,
-  findMap
+  findMap,
+  tapNone
 } from '../option.js';
 import { ok, err, some, none } from '../types.js';
 
@@ -176,6 +177,27 @@ describe('Option', () => {
     });
   });
 
+  describe('tapNone', () => {
+    it('runs for None and returns original', () => {
+      let called = false;
+      const result = tapNone(none, () => {
+        called = true;
+      });
+      expect(isNone(result)).toBe(true);
+      expect(called).toBe(true);
+    });
+
+    it('does not run for Some', () => {
+      let called = false;
+      const opt = of(5);
+      const result = tapNone(opt, () => {
+        called = true;
+      });
+      expect(result).toBe(opt);
+      expect(called).toBe(false);
+    });
+  });
+
   describe('filter', () => {
     it('keeps Some if predicate is true', () => {
       const result = filter(of(5), x => x > 3);

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)];
 }