initial commit

benchmarks/scenarios/memory.bench.ts

@@ -0,0 +1,171 @@
+import { bench, describe } from 'vitest';
+import { QUICK } from '../helpers/bench-options.js';
+import {
+  ok,
+  err,
+  some,
+  none,
+  okSome,
+  okNone,
+  errNone,
+  ntOk,
+  ntErr,
+  TsOk,
+  TsErr,
+  TsSome,
+  TsNone,
+  OxOk,
+  OxErr,
+  OxSome,
+  OxNone,
+  E,
+  O,
+  TmResult,
+  TmMaybe,
+} from '../helpers/imports.js';
+
+// ---------------------------------------------------------------------------
+// Singleton reuse: None / OkNone
+// ---------------------------------------------------------------------------
+
+describe('Memory: 1000x None creation (singleton vs constructor)', () => {
+  bench('native-monad none() — frozen singleton', () => {
+    for (let i = 0; i < 1000; i++) none();
+  }, QUICK);
+
+  bench('ts-results-es None — constant', () => {
+    for (let i = 0; i < 1000; i++) { const _ = TsNone; }
+  }, QUICK);
+
+  bench('oxide.ts None — constant', () => {
+    for (let i = 0; i < 1000; i++) { const _ = OxNone; }
+  }, QUICK);
+
+  bench('fp-ts O.none — constant', () => {
+    for (let i = 0; i < 1000; i++) { const _ = O.none; }
+  }, QUICK);
+
+  bench('true-myth Maybe.nothing() — constructor', () => {
+    for (let i = 0; i < 1000; i++) TmMaybe.nothing();
+  }, QUICK);
+});
+
+describe('Memory: 1000x OkNone creation', () => {
+  bench('native-monad okNone() — frozen singleton', () => {
+    for (let i = 0; i < 1000; i++) okNone();
+  }, QUICK);
+
+  bench('fp-ts E.right(O.none) — two allocations', () => {
+    for (let i = 0; i < 1000; i++) E.right(O.none);
+  }, QUICK);
+});
+
+// ---------------------------------------------------------------------------
+// Constructor allocation: Ok / Some / OkSome
+// ---------------------------------------------------------------------------
+
+describe('Memory: 1000x Ok construction', () => {
+  bench('native-monad ok(i) — class instance', () => {
+    for (let i = 0; i < 1000; i++) ok(i);
+  }, QUICK);
+
+  bench('neverthrow ok(i) — class instance', () => {
+    for (let i = 0; i < 1000; i++) ntOk(i);
+  }, QUICK);
+
+  bench('ts-results-es Ok(i) — class instance', () => {
+    for (let i = 0; i < 1000; i++) TsOk(i);
+  }, QUICK);
+
+  bench('oxide.ts Ok(i) — tagged object', () => {
+    for (let i = 0; i < 1000; i++) OxOk(i);
+  }, QUICK);
+
+  bench('fp-ts E.right(i) — tagged object', () => {
+    for (let i = 0; i < 1000; i++) E.right(i);
+  }, QUICK);
+
+  bench('true-myth Result.ok(i) — class instance', () => {
+    for (let i = 0; i < 1000; i++) TmResult.ok(i);
+  }, QUICK);
+});
+
+describe('Memory: 1000x Some construction', () => {
+  bench('native-monad some(i)', () => {
+    for (let i = 0; i < 1000; i++) some(i);
+  }, QUICK);
+
+  bench('ts-results-es Some(i)', () => {
+    for (let i = 0; i < 1000; i++) TsSome(i);
+  }, QUICK);
+
+  bench('oxide.ts Some(i)', () => {
+    for (let i = 0; i < 1000; i++) OxSome(i);
+  }, QUICK);
+
+  bench('fp-ts O.some(i)', () => {
+    for (let i = 0; i < 1000; i++) O.some(i);
+  }, QUICK);
+
+  bench('true-myth Maybe.just(i)', () => {
+    for (let i = 0; i < 1000; i++) TmMaybe.just(i);
+  }, QUICK);
+});
+
+describe('Memory: 1000x Err construction', () => {
+  bench('native-monad err(i)', () => {
+    for (let i = 0; i < 1000; i++) err(`err-${i}`);
+  }, QUICK);
+
+  bench('neverthrow err(i)', () => {
+    for (let i = 0; i < 1000; i++) ntErr(`err-${i}`);
+  }, QUICK);
+
+  bench('ts-results-es Err(i)', () => {
+    for (let i = 0; i < 1000; i++) TsErr(`err-${i}`);
+  }, QUICK);
+
+  bench('oxide.ts Err(i)', () => {
+    for (let i = 0; i < 1000; i++) OxErr(`err-${i}`);
+  }, QUICK);
+
+  bench('fp-ts E.left(i)', () => {
+    for (let i = 0; i < 1000; i++) E.left(`err-${i}`);
+  }, QUICK);
+
+  bench('true-myth Result.err(i)', () => {
+    for (let i = 0; i < 1000; i++) TmResult.err(`err-${i}`);
+  }, QUICK);
+});
+
+// ---------------------------------------------------------------------------
+// Three-state: OkSome vs nested allocation
+// ---------------------------------------------------------------------------
+
+describe('Memory: 1000x OkSome (single vs nested allocation)', () => {
+  bench('native-monad okSome(i) — single class', () => {
+    for (let i = 0; i < 1000; i++) okSome(i);
+  }, QUICK);
+
+  bench('fp-ts E.right(O.some(i)) — two objects', () => {
+    for (let i = 0; i < 1000; i++) E.right(O.some(i));
+  }, QUICK);
+
+  bench('ts-results-es Ok(Some(i)) — two classes', () => {
+    for (let i = 0; i < 1000; i++) TsOk(TsSome(i));
+  }, QUICK);
+});
+
+describe('Memory: 1000x ErrNone (single vs nested allocation)', () => {
+  bench('native-monad errNone(i) — single class', () => {
+    for (let i = 0; i < 1000; i++) errNone(`err-${i}`);
+  }, QUICK);
+
+  bench('fp-ts E.left(i) — single object', () => {
+    for (let i = 0; i < 1000; i++) E.left(`err-${i}`);
+  }, QUICK);
+
+  bench('ts-results-es Err(i) — single class', () => {
+    for (let i = 0; i < 1000; i++) TsErr(`err-${i}`);
+  }, QUICK);
+});