nalloc 0.0.3 → 0.2.0

package/build/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/** Values that represent None (absence of a value). */\nexport type NoneValueType = null | undefined | void;\n\n/** Widens literal types to their base types for better type inference. */\nexport type Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T extends symbol\n          ? symbol\n          : T;\n\n/** Widens never to unknown, otherwise preserves the type. */\nexport type WidenNever<T> = [T] extends [never] ? unknown : T;\n\n/** Excludes None values from a type, leaving only valid Some values. */\nexport type ValueType<T> = Exclude<T, NoneValueType>;\n\nexport declare const SOME_BRAND: unique symbol;\n\n/** Represents a value that is present. The value itself is the Some - no wrapper object. */\nexport type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };\n\n/** Represents the absence of a value (null or undefined). */\nexport type None = NoneValueType & { readonly [SOME_BRAND]: false };\n\n/** Constant representing None. Use this instead of null/undefined for clarity. */\nexport const NONE = undefined as None;\n\n/** Shared frozen empty array to avoid allocations. */\nexport const EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */\nexport type Option<T> = Some<ValueType<T>> | None;\n\n/** Extracts the value type from an Option type. */\nexport type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;\n\n/** Type predicate: true if T is an Option type. */\nexport type IsOption<T> = T extends Option<any> ? true : false;\n\n/** Infers the Some type from a value, preserving the inner type. */\nexport type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;\n\n/**\n * Checks if an Option contains a value (is Some).\n * @param opt - The Option to check\n * @returns true if the Option is Some, false if None\n * @example\n * isSome(42)        // true\n * isSome(null)      // false\n * isSome(undefined) // false\n */\nexport function isSome<T>(opt: Some<T>): true;\nexport function isSome(opt: None): false;\nexport function isSome<T>(opt: unknown): opt is Some<T>;\nexport function isSome(opt: unknown): boolean {\n  return opt !== null && opt !== undefined;\n}\n\n/**\n * Checks if an Option is None (absent).\n * @param opt - The Option to check\n * @returns true if the Option is None, false if Some\n * @example\n * isNone(null)      // true\n * isNone(undefined) // true\n * isNone(42)        // false\n */\nexport function isNone<T>(opt: Some<T>): false;\nexport function isNone(opt: None): true;\nexport function isNone(opt: unknown): opt is None;\nexport function isNone(opt: unknown): boolean {\n  return opt === null || opt === undefined;\n}\n\n/**\n * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.\n * @param value - The value to wrap\n * @returns Some(value) if value is non-null, None otherwise\n * @example\n * optionOf(42)        // Some(42)\n * optionOf(null)      // None\n * optionOf(undefined) // None\n */\nexport function optionOf(value: null): None;\nexport function optionOf(value: undefined): None;\nexport function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;\nexport function optionOf<T>(value: T): Option<T> {\n  return isNone(value as Option<T>) ? NONE : (value as Some<T>);\n}\n\nexport function someUnchecked<T>(value: T): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/**\n * Creates a Some value with runtime validation.\n * @param value - The value to wrap\n * @returns The value typed as Some\n * @throws TypeError if value is null or undefined\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnchecked(value);\n}\n\n/** Constant representing None. Alias for NONE. */\nexport const none: None = NONE;\n\ndeclare const OK_BRAND: unique symbol;\n\n/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */\nexport type Ok<T> = T & { readonly [OK_BRAND]: true };\n\nconst ERR_BRAND = Symbol.for('nalloc.ResultError');\n\ninterface ResultErrorShape<E> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultErrorCtor.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/** The error wrapper type used internally. */\nexport type ResultError<E> = ResultErrorShape<E>;\n\n/** Represents a failed Result containing an error. */\nexport type Err<E> = ResultError<E>;\n\n/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** Extracts the success value type from a Result type. */\nexport type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;\n\n/** Extracts the error type from a Result type. */\nexport type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;\n\n/** Type predicate: true if T is a Result type. */\nexport type IsResult<T> = T extends Result<any, any> ? true : false;\n\n/** Infers the Err type from a value, preserving the error type. */\nexport type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;\n\n/**\n * Checks if a Result is Ok (successful).\n * @param result - The Result to check\n * @returns true if the Result is Ok, false if Err\n * @example\n * isOk(42)           // true (Ok value)\n * isOk(err('fail'))  // false\n */\nexport function isOk<T>(result: Ok<T>): true;\nexport function isOk<E>(result: Err<E>): false;\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T>;\nexport function isOk(result: unknown): boolean;\nexport function isOk(result: unknown): boolean {\n  return typeof result !== 'object' || result === null || !(result as Record<symbol, boolean>)[ERR_BRAND];\n}\n\n/**\n * Checks if a Result is Err (failed).\n * @param result - The Result to check\n * @returns true if the Result is Err, false if Ok\n * @example\n * isErr(err('fail')) // true\n * isErr(42)          // false (Ok value)\n */\nexport function isErr<E>(result: Err<E>): true;\nexport function isErr(result: Ok<unknown>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr(result: unknown): result is Err<unknown>;\nexport function isErr(result: unknown): boolean {\n  return typeof result === 'object' && result !== null && (result as Record<symbol, boolean>)[ERR_BRAND] === true;\n}\n\nexport function okUnchecked<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws TypeError if value is an Err\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnchecked(value);\n}\n\n/**\n * Creates an Err value wrapping an error.\n * @param error - The error value\n * @returns An Err containing the error\n * @example\n * err('something went wrong') // Err('something went wrong')\n * err(new Error('failed'))    // Err(Error)\n */\nexport function err<E>(error: E): Err<E> {\n  return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);\n}\n\n/** A value that may or may not be a Promise. */\nexport type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;\n\n/**\n * Checks if a value is a thenable (has a .then method).\n * @param value - The value to check\n * @returns true if value is a PromiseLike\n */\nexport function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return typeof (value as PromiseLike<T>)?.then === 'function';\n}\n\n/**\n * Checks if a value is synchronous (not a thenable).\n * @param value - The value to check\n * @returns true if value is not a PromiseLike\n */\nexport function isSync<T>(value: MaybePromise<T>): value is T {\n  return typeof (value as PromiseLike<T>)?.then !== 'function';\n}\n"],"names":["NONE","undefined","EMPTY","Object","freeze","isSome","opt","isNone","optionOf","value","someUnchecked","some","TypeError","none","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","isOk","result","isErr","okUnchecked","ok","err","isThenable","then","isSync"],"mappings":"AA+BA,OAAO,MAAMA,OAAOC,UAAkB;AAGtC,OAAO,MAAMC,QAA4BC,OAAOC,MAAM,CAAC,EAAE,EAAE;AA0B3D,OAAO,SAASC,OAAOC,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASM,OAAOD,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASO,SAAYC,KAAQ;IAClC,OAAOF,OAAOE,SAAsBT,OAAQS;AAC9C;AAEA,OAAO,SAASC,cAAiBD,KAAQ;IACvC,OAAOA;AACT;AAUA,OAAO,SAASE,KAAQF,KAAmB;IACzC,IAAIA,UAAU,QAAQA,UAAUR,WAAW;QACzC,MAAM,IAAIW,UAAU;IACtB;IACA,OAAOF,cAAcD;AACvB;AAGA,OAAO,MAAMI,OAAab,KAAK;AAO/B,MAAMc,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAmClE,OAAO,SAASM,KAAKC,MAAe;IAClC,OAAO,OAAOA,WAAW,YAAYA,WAAW,QAAQ,CAAC,AAACA,MAAkC,CAACP,UAAU;AACzG;AAcA,OAAO,SAASQ,MAAMD,MAAe;IACnC,OAAO,OAAOA,WAAW,YAAYA,WAAW,QAAQ,AAACA,MAAkC,CAACP,UAAU,KAAK;AAC7G;AAEA,OAAO,SAASS,YAAed,KAAQ;IACrC,OAAOA;AACT;AAUA,OAAO,SAASe,GAAMf,KAAQ;IAC5B,IAAIa,MAAMb,QAAQ;QAChB,MAAM,IAAIG,UAAU;IACtB;IACA,OAAOW,YAAYd;AACrB;AAUA,OAAO,SAASgB,IAAOP,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE;AAUA,OAAO,SAASQ,WAAcjB,KAAsB;IAClD,OAAO,OAAQA,OAA0BkB,SAAS;AACpD;AAOA,OAAO,SAASC,OAAUnB,KAAsB;IAC9C,OAAO,OAAQA,OAA0BkB,SAAS;AACpD"}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/** Values that represent None (absence of a value). */\nexport type NoneValueType = null | undefined | void;\n\n/** Widens literal types to their base types for better type inference. */\nexport type Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T extends symbol\n          ? symbol\n          : T;\n\n/** Widens never to unknown, otherwise preserves the type. */\nexport type WidenNever<T> = [T] extends [never] ? unknown : T;\n\n/** Excludes None values from a type, leaving only valid Some values. */\nexport type ValueType<T> = Exclude<T, NoneValueType>;\n\nexport declare const SOME_BRAND: unique symbol;\n\n/** Represents a value that is present. The value itself is the Some - no wrapper object. */\nexport type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };\n\n/** Represents the absence of a value (null or undefined). */\nexport type None = NoneValueType & { readonly [SOME_BRAND]: false };\n\nexport type UnOption<V, T extends Option<V>> = T extends Some<V> ? V : None;\n\n/** Constant representing None. Use this instead of null/undefined for clarity. */\nexport const NONE = undefined as None;\n\n/** Shared frozen empty array to avoid allocations. */\nexport const EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */\nexport type Option<T> = Some<ValueType<T>> | None;\n\n/** Extracts the value type from an Option type. */\nexport type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;\n\n/** Type predicate: true if T is an Option type. */\nexport type IsOption<T> = T extends Option<any> ? true : false;\n\n/** Infers the Some type from a value, preserving the inner type. */\nexport type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;\n\n/**\n * Checks if an Option contains a value (is Some).\n * @param opt - The Option to check\n * @returns true if the Option is Some, false if None\n * @example\n * isSome(42)        // true\n * isSome(null)      // false\n * isSome(undefined) // false\n */\nexport function isSome<T>(opt: Some<T>): true;\nexport function isSome(opt: None): false;\nexport function isSome<T>(opt: unknown): opt is Some<T>;\nexport function isSome(opt: unknown): boolean {\n  return opt !== null && opt !== undefined;\n}\n\n/**\n * Checks if an Option is None (absent).\n * @param opt - The Option to check\n * @returns true if the Option is None, false if Some\n * @example\n * isNone(null)      // true\n * isNone(undefined) // true\n * isNone(42)        // false\n */\nexport function isNone<T>(opt: Some<T>): false;\nexport function isNone(opt: None): true;\nexport function isNone(opt: unknown): opt is None;\nexport function isNone(opt: unknown): boolean {\n  return opt === null || opt === undefined;\n}\n\n/**\n * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.\n * @param value - The value to wrap\n * @returns Some(value) if value is non-null, None otherwise\n * @example\n * optionOf(42)        // Some(42)\n * optionOf(null)      // None\n * optionOf(undefined) // None\n */\nexport function optionOf(value: null): None;\nexport function optionOf(value: undefined): None;\nexport function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;\nexport function optionOf<T>(value: T): Option<T> {\n  return isNone(value as Option<T>) ? NONE : (value as Some<T>);\n}\n\nexport function someUnchecked<T>(value: T): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/**\n * Creates a Some value with runtime validation.\n * @param value - The value to wrap\n * @returns The value typed as Some\n * @throws TypeError if value is null or undefined\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnchecked(value);\n}\n\n/** Constant representing None. Alias for NONE. */\nexport const none: None = NONE;\n\ndeclare const OK_BRAND: unique symbol;\n\n/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */\nexport type Ok<T> = T & { readonly [OK_BRAND]: true };\n\nconst ERR_BRAND = Symbol.for('nalloc.ResultError');\n\ninterface ResultErrorShape<E> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultErrorCtor.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/** The error wrapper type used internally. */\nexport type ResultError<E> = ResultErrorShape<E>;\n\n/** Represents a failed Result containing an error. */\nexport type Err<E> = ResultError<E>;\n\n/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** Extracts the success value type from a Result type. */\nexport type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;\n\n/** Extracts the error type from a Result type. */\nexport type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;\n\n/** Type predicate: true if T is a Result type. */\nexport type IsResult<T> = T extends Result<any, any> ? true : false;\n\n/** Infers the Err type from a value, preserving the error type. */\nexport type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;\n\n/**\n * Checks if a Result is Ok (successful).\n * @param result - The Result to check\n * @returns true if the Result is Ok, false if Err\n * @example\n * isOk(42)           // true (Ok value)\n * isOk(err('fail'))  // false\n */\nexport function isOk<T>(result: Ok<T>): true;\nexport function isOk<E>(result: Err<E>): false;\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T>;\nexport function isOk(result: unknown): boolean;\nexport function isOk(result: unknown): boolean {\n  return typeof result !== 'object' || result === null || !(result as Record<symbol, boolean>)[ERR_BRAND];\n}\n\n/**\n * Checks if a Result is Err (failed).\n * @param result - The Result to check\n * @returns true if the Result is Err, false if Ok\n * @example\n * isErr(err('fail')) // true\n * isErr(42)          // false (Ok value)\n */\nexport function isErr<E>(result: Err<E>): true;\nexport function isErr(result: Ok<unknown>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr(result: unknown): result is Err<unknown>;\nexport function isErr(result: unknown): boolean {\n  return typeof result === 'object' && result !== null && (result as Record<symbol, boolean>)[ERR_BRAND] === true;\n}\n\nexport function okUnchecked<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws TypeError if value is an Err\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnchecked(value);\n}\n\n/**\n * Creates an Err value wrapping an error.\n * @param error - The error value\n * @returns An Err containing the error\n * @example\n * err('something went wrong') // Err('something went wrong')\n * err(new Error('failed'))    // Err(Error)\n */\nexport function err<E>(error: E): Err<E> {\n  return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);\n}\n\n/** A value that may or may not be a Promise. */\nexport type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;\n\n/**\n * Checks if a value is a thenable (has a .then method).\n * @param value - The value to check\n * @returns true if value is a PromiseLike\n */\nexport function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {\n  return (typeof value === 'object' || typeof value === 'function') && value !== null && typeof (value as PromiseLike<T>).then === 'function';\n}\n\n/**\n * Checks if a value is synchronous (not a thenable).\n * @param value - The value to check\n * @returns true if value is not a PromiseLike\n */\nexport function isSync<T>(value: MaybePromise<T>): value is T {\n  return !(typeof value === 'object' || typeof value === 'function') || value === null || typeof (value as PromiseLike<T>).then !== 'function';\n}\n"],"names":["NONE","undefined","EMPTY","Object","freeze","isSome","opt","isNone","optionOf","value","someUnchecked","some","TypeError","none","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","isOk","result","isErr","okUnchecked","ok","err","isThenable","then","isSync"],"mappings":"AAiCA,OAAO,MAAMA,OAAOC,UAAkB;AAGtC,OAAO,MAAMC,QAA4BC,OAAOC,MAAM,CAAC,EAAE,EAAE;AA0B3D,OAAO,SAASC,OAAOC,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASM,OAAOD,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQL;AACjC;AAcA,OAAO,SAASO,SAAYC,KAAQ;IAClC,OAAOF,OAAOE,SAAsBT,OAAQS;AAC9C;AAEA,OAAO,SAASC,cAAiBD,KAAQ;IACvC,OAAOA;AACT;AAUA,OAAO,SAASE,KAAQF,KAAmB;IACzC,IAAIA,UAAU,QAAQA,UAAUR,WAAW;QACzC,MAAM,IAAIW,UAAU;IACtB;IACA,OAAOF,cAAcD;AACvB;AAGA,OAAO,MAAMI,OAAab,KAAK;AAO/B,MAAMc,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAmClE,OAAO,SAASM,KAAKC,MAAe;IAClC,OAAO,OAAOA,WAAW,YAAYA,WAAW,QAAQ,CAAC,AAACA,MAAkC,CAACP,UAAU;AACzG;AAcA,OAAO,SAASQ,MAAMD,MAAe;IACnC,OAAO,OAAOA,WAAW,YAAYA,WAAW,QAAQ,AAACA,MAAkC,CAACP,UAAU,KAAK;AAC7G;AAEA,OAAO,SAASS,YAAed,KAAQ;IACrC,OAAOA;AACT;AAUA,OAAO,SAASe,GAAMf,KAAQ;IAC5B,IAAIa,MAAMb,QAAQ;QAChB,MAAM,IAAIG,UAAU;IACtB;IACA,OAAOW,YAAYd;AACrB;AAUA,OAAO,SAASgB,IAAOP,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE;AAUA,OAAO,SAASQ,WAAcjB,KAAsB;IAClD,OAAO,AAAC,CAAA,OAAOA,UAAU,YAAY,OAAOA,UAAU,UAAS,KAAMA,UAAU,QAAQ,OAAO,AAACA,MAAyBkB,IAAI,KAAK;AACnI;AAOA,OAAO,SAASC,OAAUnB,KAAsB;IAC9C,OAAO,CAAE,CAAA,OAAOA,UAAU,YAAY,OAAOA,UAAU,UAAS,KAAMA,UAAU,QAAQ,OAAO,AAACA,MAAyBkB,IAAI,KAAK;AACpI"}

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.3",
+  "version": "0.2.0",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -50,15 +50,32 @@
     "result",
     "maybe",
     "either",
+    "ok",
+    "err",
+    "some",
+    "none",
+    "unwrap",
     "rust",
     "typescript",
     "type-safe",
     "monad",
     "functional",
+    "fp",
+    "adt",
+    "algebraic-data-types",
+    "discriminated-union",
     "error-handling",
+    "try-catch",
+    "safe",
+    "nullable",
+    "null-safety",
     "pattern-matching",
     "zero-allocation",
-    "performance"
+    "no-allocation",
+    "gc-friendly",
+    "performance",
+    "neverthrow-alternative",
+    "fp-ts-alternative"
   ],
   "author": "Ivan Zakharchanka",
   "license": "MIT",
@@ -68,23 +85,25 @@
   "homepage": "https://github.com/3axap4eHko/nalloc#readme",
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@vitest/coverage-v8": "^4.0.18",
-    "eslint": "^10.0.2",
+    "@vitest/coverage-v8": "^4.1.2",
+    "eslint": "^10.1.0",
     "eslint-plugin-prettier": "^5.5.5",
     "inop": "^0.9.0",
-    "overtake": "^1.4.0",
+    "overtake": "^2.1.1",
     "prettier": "^3.8.1",
     "tsafe": "^1.8.12",
     "tslib": "^2.8.1",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.56.1",
-    "vitest": "^4.0.18"
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.0",
+    "vitest": "^4.1.2"
   },
   "scripts": {
-    "check": "tsc src/__tests__/option.types.ts src/__tests__/result.types.ts --noEmit --lib esnext,dom --target esnext --module nodenext --moduleResolution nodenext",
+    "check": "tsc --noEmit -p tsconfig.check.json",
     "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
     "lint": "eslint .",
     "test": "vitest run",
-    "bench": "overtake benchmarks/*"
+    "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,9 +207,20 @@ 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 | string>>;
+assert<Equals<typeof unwrapFallback, number | 'fallback'>>;
 
 declare const maybeResult: Result<number, string>;
 assertOk(maybeResult);

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
@@ -158,11 +160,7 @@ export function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Opti
  * @param fn - Function returning an Option
  * @returns The result of fn(value) if Some, None otherwise
  */
-export function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;
-export function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;
-export function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {
-  return isNone(opt) ? NONE : fn(opt);
-}
+export const andThen: typeof flatMap = flatMap;
 
 /**
  * Executes a side effect if Some, then returns the original Option.
@@ -182,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
@@ -355,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)];
 }
@@ -412,7 +428,7 @@ export function flatten<T>(opt: Option<Option<T>>): Option<T> {
  * contains(none, 42)     // false
  */
 export function contains<T>(opt: Option<T>, value: T): boolean {
-  return isSome(opt) && opt === value;
+  return isSome(opt) && (opt === value || (opt !== opt && value !== value));
 }
 
 /**