nalloc 0.0.2 → 0.1.0

package/build/types.d.ts

@@ -15,6 +15,7 @@ export type Some<T> = ValueType<T> & {
 export type None = NoneValueType & {
     readonly [SOME_BRAND]: false;
 };
+export type UnOption<V, T extends Option<V>> = T extends Some<V> ? V : None;
 /** Constant representing None. Use this instead of null/undefined for clarity. */
 export declare const NONE: None;
 /** Shared frozen empty array to avoid allocations. */

package/build/types.js

@@ -25,10 +25,10 @@ function ResultErrorCtor(error) {
 }
 ResultErrorCtor.prototype[ERR_BRAND] = true;
 export function isOk(result) {
-    return !result?.[ERR_BRAND];
+    return typeof result !== 'object' || result === null || !result[ERR_BRAND];
 }
 export function isErr(result) {
-    return result?.[ERR_BRAND] === true;
+    return typeof result === 'object' && result !== null && result[ERR_BRAND] === true;
 }
 export function okUnchecked(value) {
     return value;
@@ -43,10 +43,10 @@ export function err(error) {
     return new ResultErrorCtor(error);
 }
 export function isThenable(value) {
-    return typeof value?.then === 'function';
+    return (typeof value === 'object' || typeof value === 'function') && value !== null && typeof value.then === 'function';
 }
 export function isSync(value) {
-    return typeof value?.then !== 'function';
+    return !(typeof value === 'object' || typeof value === 'function') || value === null || typeof value.then !== 'function';
 }
 
 //# sourceMappingURL=types.js.map

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 !(result as Record<symbol, unknown>)?.[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 (result as Record<symbol, unknown>)?.[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,CAAEA,QAAoC,CAACP,UAAU;AAC1D;AAcA,OAAO,SAASQ,MAAMD,MAAe;IACnC,OAAO,AAACA,QAAoC,CAACP,UAAU,KAAK;AAC9D;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.2",
+  "version": "0.1.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 2 --progress",
+    "bench:save": "pnpm bench --save-baseline .bench-baseline.json",
+    "bench:test": "pnpm bench --compare-baseline .bench-baseline.json"
   }
 }

package/src/__tests__/result.ts

@@ -45,7 +45,8 @@ import {
   filterOk,
   filterErr,
   safeTry,
-  safeTryAsync
+  safeTryAsync,
+  fromPromise
 } from '../result.js';
 import { ok, err, isOk, isErr, optionOf as optOf, none } from '../types.js';
 
@@ -913,4 +914,39 @@ describe('Result', () => {
     });
   });
 
+  describe('fromPromise', () => {
+    it('returns Ok for resolved promise', async () => {
+      const result = await fromPromise(Promise.resolve(42));
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(42);
+    });
+
+    it('returns Err for rejected promise', async () => {
+      const result = await fromPromise(Promise.reject(new Error('boom')));
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: Error }).error.message).toBe('boom');
+    });
+
+    it('uses onError mapper for rejected promise', async () => {
+      const result = await fromPromise(
+        Promise.reject(new Error('boom')),
+        (e) => `mapped: ${(e as Error).message}`,
+      );
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('mapped: boom');
+    });
+
+    it('handles Ok(null) as valid success', async () => {
+      const result = await fromPromise(Promise.resolve(null));
+      expect(isOk(result)).toBe(true);
+      expect(result).toBe(null);
+    });
+
+    it('returns Err with unknown type when no onError provided', async () => {
+      const result = await fromPromise(Promise.reject('string error'));
+      expect(isErr(result)).toBe(true);
+      expect((result as { error: string }).error).toBe('string error');
+    });
+  });
+
 });

package/src/__tests__/result.types.ts

@@ -207,7 +207,7 @@ assert<Equals<typeof tryCatchTyped, Result<number, string>>>;
 
 
 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/option.ts

@@ -158,11 +158,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.
@@ -312,8 +308,9 @@ export function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {
  * xor(none, none)       // None
  */
 export function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {
-  if (isSome(opt) && isNone(optb)) return opt;
-  if (isNone(opt) && isSome(optb)) return optb;
+  const a = isSome(opt);
+  const b = isSome(optb);
+  if (a !== b) return a ? opt : optb;
   return NONE;
 }
 
@@ -411,7 +408,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));
 }
 
 /**

package/src/result.ts

@@ -33,6 +33,25 @@ export function of<T>(fn: () => T): Result<T, unknown> {
   return tryCatch(fn);
 }
 
+/**
+ * Converts a Promise to a Result. Resolves to Ok if successful, Err on rejection.
+ * @param promise - The promise to convert
+ * @param onError - Optional error transformer
+ * @returns Promise resolving to Ok(value) or Err(error)
+ * @example
+ * await fromPromise(fetch('/api'))              // Ok(Response) or Err(unknown)
+ * await fromPromise(fetch('/api'), e => String(e)) // Ok(Response) or Err(string)
+ */
+export async function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;
+export async function fromPromise<T, E>(promise: Promise<T>, onError: (error: unknown) => E): Promise<Result<T, E>>;
+export async function fromPromise<T, E = unknown>(promise: Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {
+  try {
+    return (await promise) as Ok<T>;
+  } catch (error) {
+    return ERR(onError ? onError(error) : (error as E));
+  }
+}
+
 /**
  * Executes a function that may return sync or async, preserving sync execution when possible.
  * @param fn - Function that may return T or Promise<T>
@@ -99,7 +118,7 @@ export function assertOk<T, E>(result: Result<T, E>, message?: string): asserts
  */
 export function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {
   if (isOk(result)) {
-    throw new Error(message ?? 'Expected Err result.');
+    throw new Error(message ?? `Expected Err result. Received value: ${String(result)}`);
   }
 }
 
@@ -169,11 +188,7 @@ export function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<
  * @param fn - Function returning a Result
  * @returns The result of fn(value) if Ok, Err unchanged
  */
-export function andThen<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;
-export function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
-export function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {
-  return isErr(result) ? result : fn(result);
-}
+export const andThen: typeof flatMap = flatMap;
 
 /**
  * Executes a side effect if Ok, then returns the original Result.
@@ -532,11 +547,13 @@ export function filterErr<T, E>(results: Iterable<Result<T, E>>): E[] {
  * collect([ok(1), err('e')])    // Err('e')
  */
 export function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {
-  const values: T[] = [];
+  const len = results.length;
+  const values = new Array<T>(len);
 
-  for (const result of results) {
+  for (let i = 0; i < len; i++) {
+    const result = results[i];
     if (isErr(result)) return result;
-    values.push(result);
+    values[i] = result;
   }
 
   return values as Ok<T[]>;
@@ -551,7 +568,15 @@ export function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {
  * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])
  */
 export function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {
-  const [oks, errs] = partition(results);
+  const oks: T[] = [];
+  const errs: E[] = [];
+  for (const result of results) {
+    if (isOk(result)) {
+      oks.push(result);
+    } else {
+      errs.push(result.error);
+    }
+  }
   return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);
 }
 
@@ -688,25 +713,38 @@ export async function partitionMaybePromiseAsync<T, E>(
   startIndex: number = 0,
 ): Promise<[Widen<T>[], WidenNever<E>[]]> {
   const suffixLength = values.length - startIndex;
-  const pending = new Array<Promise<Result<T, E>>>(suffixLength);
+  const pendingPromises: Promise<Result<T, E>>[] = [];
 
   for (let i = 0; i < suffixLength; i++) {
     const value = values[startIndex + i];
-    pending[i] = Promise.resolve(value).then(
-      (result) => result as Result<T, E>,
-      (error) => ERR(error as E),
-    );
+    if (isThenable(value)) {
+      pendingPromises.push(
+        Promise.resolve(value).then(
+          (result) => result as Result<T, E>,
+          (error) => ERR(error as E),
+        ),
+      );
+    } else {
+      if (isOk(value)) {
+        oks.push(value as Widen<T>);
+      } else {
+        errs.push((value as Err<WidenNever<E>>).error);
+      }
+    }
   }
 
-  const resolved = await Promise.all(pending);
-  for (let i = 0; i < resolved.length; i++) {
-    const result = resolved[i];
-    if (isOk(result)) {
-      oks.push(result as Widen<T>);
-    } else {
-      errs.push((result as Err<WidenNever<E>>).error);
+  if (pendingPromises.length > 0) {
+    const resolved = await Promise.all(pendingPromises);
+    for (let i = 0; i < resolved.length; i++) {
+      const result = resolved[i];
+      if (isOk(result)) {
+        oks.push(result as Widen<T>);
+      } else {
+        errs.push((result as Err<WidenNever<E>>).error);
+      }
     }
   }
+
   return [oks, errs] as [Widen<T>[], WidenNever<E>[]];
 }
 

package/src/types.ts

@@ -28,6 +28,8 @@ export type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };
 /** Represents the absence of a value (null or undefined). */
 export type None = NoneValueType & { readonly [SOME_BRAND]: false };
 
+export type UnOption<V, T extends Option<V>> = T extends Some<V> ? V : None;
+
 /** Constant representing None. Use this instead of null/undefined for clarity. */
 export const NONE = undefined as None;
 
@@ -167,7 +169,7 @@ export function isOk<E>(result: Err<E>): false;
 export function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
 export function isOk(result: unknown): boolean;
 export function isOk(result: unknown): boolean {
-  return !(result as Record<symbol, unknown>)?.[ERR_BRAND];
+  return typeof result !== 'object' || result === null || !(result as Record<symbol, boolean>)[ERR_BRAND];
 }
 
 /**
@@ -183,7 +185,7 @@ export function isErr(result: Ok<unknown>): false;
 export function isErr<T, E>(result: Result<T, E>): result is Err<E>;
 export function isErr(result: unknown): result is Err<unknown>;
 export function isErr(result: unknown): boolean {
-  return (result as Record<symbol, unknown>)?.[ERR_BRAND] === true;
+  return typeof result === 'object' && result !== null && (result as Record<symbol, boolean>)[ERR_BRAND] === true;
 }
 
 export function okUnchecked<T>(value: T): Ok<T> {
@@ -226,7 +228,7 @@ export type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;
  * @returns true if value is a PromiseLike
  */
 export function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {
-  return typeof (value as PromiseLike<T>)?.then === 'function';
+  return (typeof value === 'object' || typeof value === 'function') && value !== null && typeof (value as PromiseLike<T>).then === 'function';
 }
 
 /**
@@ -235,5 +237,5 @@ export function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {
  * @returns true if value is not a PromiseLike
  */
 export function isSync<T>(value: MaybePromise<T>): value is T {
-  return typeof (value as PromiseLike<T>)?.then !== 'function';
+  return !(typeof value === 'object' || typeof value === 'function') || value === null || typeof (value as PromiseLike<T>).then !== 'function';
 }