functype 0.46.1 → 0.47.0

package/dist/cli/index.js

@@ -1,645 +1,8 @@
 #!/usr/bin/env node
-import{P as e}from"../Valuable-BlffnwkD.js";import{Option as t}from"../option/index.js";import{List as n}from"../list/index.js";const r=`0.46.1`,i={Option:{description:`Safe nullable handling - Some<T> or None`,interfaces:[`Functor`,`Monad`,`Foldable`,`Extractable`,`Matchable`,`Serializable`,`Traversable`],methods:{create:[`Option(v)`,`Option.none()`,`Some(v)`,`None()`],transform:[`.map(f)`,`.flatMap(f)`,`.filter(p)`,`.ap(ff)`],extract:[`.fold(n, s)`,`.orElse(d)`,`.orThrow()`,`.orNull()`,`.match({Some, None})`],check:[`.isSome`,`.isNone`,`.isDefined`,`.isEmpty`]}},Either:{description:`Error handling with Left (error) or Right (success)`,interfaces:[`Functor`,`Monad`,`Foldable`,`Traversable`,`PromiseLike`],methods:{create:[`Right(v)`,`Left(e)`,`Either.right(v)`,`Either.left(e)`],transform:[`.map(f)`,`.flatMap(f)`,`.mapLeft(f)`,`.swap()`],extract:[`.fold(l, r)`,`.orElse(d)`,`.orThrow()`,`.match({Left, Right})`],check:[`.isRight`,`.isLeft`]}},Try:{description:`Wrap operations that may throw - Success<T> or Failure`,interfaces:[`Functor`,`Monad`,`Foldable`,`Extractable`,`Matchable`,`Serializable`,`Traversable`],methods:{create:[`Try(() => expr)`,`Success(v)`,`Failure(e)`],transform:[`.map(f)`,`.flatMap(f)`,`.recover(f)`,`.recoverWith(f)`],extract:[`.fold(f, s)`,`.orElse(d)`,`.orThrow()`,`.toOption()`,`.toEither()`],check:[`.isSuccess`,`.isFailure`]}},List:{description:`Immutable array with functional operations`,interfaces:[`Functor`,`Monad`,`Foldable`,`Collection`,`Serializable`,`Traversable`],methods:{create:[`List([...])`,`List.of(...)`,`List.empty()`],transform:[`.map(f)`,`.flatMap(f)`,`.filter(p)`,`.take(n)`,`.takeWhile(p)`,`.takeRight(n)`,`.drop(n)`,`.dropWhile(p)`,`.concat(list)`,`.reverse()`,`.distinct()`,`.sorted()`,`.sortBy(f)`,`.zip(list)`,`.zipWithIndex()`,`.prepend(v)`,`.slice(s, e)`],extract:[`.fold(z, f)`,`.reduce(f)`,`.head`,`.headOption`,`.tail`,`.last`,`.lastOption`,`.init`,`.indexOf(v)`,`.toArray()`],check:[`.isEmpty`,`.nonEmpty`,`.size`,`.contains(v)`],other:[`.groupBy(f)`,`.partition(p)`,`.span(p)`]}},Set:{description:`Immutable set of unique values`,interfaces:[`Functor`,`Foldable`,`Collection`,`Serializable`,`Traversable`],methods:{create:[`Set([...])`,`Set.of(...)`,`Set.empty()`],transform:[`.map(f)`,`.filter(p)`,`.union(s)`,`.intersection(s)`,`.difference(s)`,`.add(v)`],extract:[`.fold(z, f)`,`.toArray()`],check:[`.has(v)`,`.isEmpty`,`.size`]}},Map:{description:`Immutable key-value store`,interfaces:[`SafeTraversable`,`Collection`,`Serializable`],methods:{create:[`Map([[k, v], ...])`,`Map.of([k, v], ...)`,`Map.empty()`],transform:[`.set(k, v)`,`.delete(k)`,`.map(f)`,`.filter(p)`,`.add(k, v)`],extract:[`.get(k)`,`.keys()`,`.values()`,`.entries()`,`.fold(z, f)`],check:[`.has(k)`,`.isEmpty`,`.size`]}},Lazy:{description:`Deferred computation with memoization`,interfaces:[`Functor`,`Monad`,`Foldable`,`Extractable`,`Serializable`,`Traversable`],methods:{create:[`Lazy(() => expr)`],transform:[`.map(f)`,`.flatMap(f)`],extract:[`.fold(n, s)`,`.orElse(d)`,`.orThrow()`,`.get()`],check:[`.isEvaluated`]}},LazyList:{description:`Lazy sequences for large/infinite data`,interfaces:[`Functor`,`Monad`,`Iterable`],methods:{create:[`LazyList.from(iter)`,`LazyList.range(start, end)`,`LazyList.infinite(f)`],transform:[`.map(f)`,`.filter(p)`,`.take(n)`,`.takeRight(n)`,`.drop(n)`,`.takeWhile(p)`,`.dropWhile(p)`,`.concat(ll)`,`.reverse()`,`.distinct()`,`.zip(ll)`,`.zipWithIndex()`],extract:[`.head`,`.headOption`,`.tail`,`.last`,`.lastOption`,`.init`,`.toArray()`],check:[`.isEmpty`]}},Task:{description:`Async operations with cancellation and progress`,interfaces:[],methods:{create:[`Task.of(v)`,`Task.from(promise)`,`Task.sync(f)`,`Task.async(f)`],transform:[`.map(f)`,`.flatMap(f)`,`.mapError(f)`],extract:[`.run()`,`.cancel()`],other:[`.onProgress(cb)`,`.onCancel(cb)`]}},IO:{description:`Lazy effect type with typed errors and dependency injection`,interfaces:[`Functor`,`Monad`,`Foldable`,`Matchable`],methods:{create:[`IO(() => v)`,`IO.succeed(v)`,`IO.fail(e)`,`IO.sync(f)`,`IO.async(f)`,`IO.tryPromise({try, catch})`,`IO.fromEither(e)`,`IO.fromOption(o)`,`IO.fromTry(t)`],transform:[`.map(f)`,`.flatMap(f)`,`.tap(f)`,`.mapError(f)`,`.recover(v)`,`.recoverWith(f)`],extract:[`.run()`,`.runOrThrow()`,`.runSync()`,`.runSyncOrThrow()`,`.runExit()`,`.runOption()`,`.runTry()`,`.fold(onErr, onOk)`,`.match({failure, success})`],check:[],other:[`.catchTag(tag, f)`,`.catchAll(f)`,`.retry(n)`,`.retryWithDelay(n, ms)`,`.timeout(ms)`,`.delay(ms)`,`.zip(io)`,`.pipe(f)`,`IO.all([...])`,`IO.race([...])`,`IO.bracket(acquire, use, release)`,`IO.gen(function*() {...})`,`IO.Do.bind().map()`,`IO.service(Tag)`,`.provideService(Tag, impl)`,`.provideLayer(layer)`]}},Cond:{description:`Conditional expression builder - replace if-else chains`,interfaces:[],methods:{create:[`Cond<T>()`],other:[`.case(pred, result)`,`.otherwise(result)`,`.eval()`]}},Match:{description:`Pattern matching - replace switch statements`,interfaces:[],methods:{create:[`Match(value)`],other:[`.case(pattern, result)`,`.when(pred, result)`,`.default(result)`,`.done()`]}},Brand:{description:`Nominal typing without runtime overhead`,interfaces:[],methods:{create:[`Brand<K, T>(value)`],extract:[`.unwrap()`,`.toString()`]}},ValidatedBrand:{description:`Branded types with runtime validation`,interfaces:[],methods:{create:[`ValidatedBrand(validator)`,`.of(v)`,`.from(v)`,`.unsafeOf(v)`],check:[`.is(v)`],other:[`.refine(validator)`]}},Tuple:{description:`Fixed-size typed array`,interfaces:[`Typeable`,`Valuable`,`Iterable`],methods:{create:[`Tuple([a, b, ...])`,`Tuple.of(a, b, ...)`],extract:[`.first`,`.second`,`.toArray()`],transform:[`.map(f)`]}},Stack:{description:`Immutable LIFO stack`,interfaces:[`Foldable`,`Collection`,`Serializable`,`Traversable`],methods:{create:[`Stack()`,`Stack.of(...)`],transform:[`.push(v)`,`.pop()`],extract:[`.peek()`,`.toArray()`],check:[`.isEmpty`,`.size`]}}},a={Functor:{description:`Transform contained values`,methods:[`.map<B>(f: A => B): Functor<B>`]},Applicative:{extends:`Functor`,description:`Apply wrapped functions`,methods:[`.ap<B>(ff: Applicative<A => B>): Applicative<B>`]},Monad:{extends:`Applicative`,description:`Chain operations returning wrapped values`,methods:[`.flatMap<B>(f: A => Monad<B>): Monad<B>`]},Foldable:{description:`Extract via pattern matching`,methods:[`.fold<B>(empty: () => B, f: A => B): B`,`.foldLeft<B>(z: B, op: (B, A) => B): B`,`.foldRight<B>(z: B, op: (A, B) => B): B`]},Extractable:{description:`Get contained value with fallback`,methods:[`.orElse(d: T): T`,`.orThrow(e?: Error): T`,`.orNull(): T | null`,`.orUndefined(): T | undefined`]},Matchable:{description:`Pattern match on type variants`,methods:[`.match<R>(patterns: Record<Tag, Handler>): R`]},Traversable:{description:`Iterate and check contents`,methods:[`.size: number`,`.isEmpty: boolean`,`.contains(v: A): boolean`,`.reduce<B>(f, init): B`]},Collection:{description:`Collection operations`,methods:[`.toArray(): A[]`,`.forEach(f: A => void): void`]},Serializable:{description:`Convert to string formats`,methods:[`.serialize().toJSON(): string`,`.serialize().toYAML(): string`]}},o={Core:[`Option`,`Either`,`Try`],Collection:[`List`,`Set`,`Map`,`LazyList`,`Tuple`,`Stack`],Effect:[`IO`,`Task`],Utility:[`Lazy`,`Cond`,`Match`,`Brand`,`ValidatedBrand`]},s=()=>{let e=n([`functype ${r} - Scala-inspired FP for TypeScript`,``]);return n(Object.entries(o)).foldLeft(e)((e,[r,a])=>{let o=e.add(r.toUpperCase());return n(a).foldLeft(o)((e,n)=>t(i[n]).fold(()=>e,t=>{let r=t.interfaces.length>0?` [${t.interfaces.join(`, `)}]`:``;return e.add(`  ${n}${r}`).add(`    ${t.description}`)})).add(``)}).concat(n([`Use: npx functype <Type> for details`,`Use: npx functype interfaces for interface reference`])).toArray().join(`
-`)},c=(e,r)=>{let i=r.interfaces.length>0?` [${r.interfaces.join(`, `)}]`:``,a=n([`create`,`transform`,`extract`,`check`,`other`]),o=n([`${e}<T>${i}`,``,r.description,``]);return a.foldLeft(o)((e,i)=>t(r.methods[i]).filter(e=>e.length>0).fold(()=>e,t=>{let r=e.add(i.toUpperCase());return n(t).foldLeft(r)((e,t)=>e.add(`  ${t}`)).add(``)})).toArray().join(`
-`).trimEnd()},l=()=>{let e=n([`INTERFACES`,``]);return n(Object.entries(a)).foldLeft(e)((e,[t,r])=>{let i=r.extends?` extends ${r.extends}`:``,a=e.add(`${t}<A>${i}`).add(`  ${r.description}`);return n(r.methods).foldLeft(a)((e,t)=>e.add(`  ${t}`)).add(``)}).toArray().join(`
-`).trimEnd()},u=e=>JSON.stringify(e,null,2),d=()=>({version:r,categories:o,types:i}),f=e=>t(i[e]).map(t=>({name:e,data:t})).or(n(Object.entries(i)).find(([t])=>t.toLowerCase()===e.toLowerCase()).map(([e,t])=>({name:e,data:t}))).orUndefined(),p=()=>Object.keys(i),m=()=>a,h={Option:`export interface Option<T extends Type> extends Functype<T, "Some" | "None">, Promisable<T>, Doable<T>, Reshapeable<T> {
-  /** The contained value (undefined for None) */
-  readonly value: T | undefined
-  /** Whether this Option contains no value */
-  isEmpty: boolean
-  /**
-   * Returns true if this Option is a Some (contains a value)
-   * @returns true if this Option contains a value, false otherwise
-   */
-  isSome(): this is Option<T> & { value: T; isEmpty: false }
-  /**
-   * Returns true if this Option is a None (contains no value)
-   * @returns true if this Option is empty, false otherwise
-   */
-  isNone(): this is Option<T> & { value: undefined; isEmpty: true }
-  /**
-   * Returns the contained value or a default value if None
-   * @param defaultValue - The value to return if this Option is None
-   * @returns The contained value or defaultValue
-   */
-  orElse(defaultValue: T): T
-  /**
-   * Returns the contained value or throws an error if None
-   * @param error - Optional custom error to throw. If not provided, throws a default error
-   * @returns The contained value
-   * @throws The specified error or a default error if the Option is None
-   */
-  orThrow(error?: Error): T
-  /**
-   * Returns this Option if it contains a value, otherwise returns the alternative container
-   * @param alternative - The alternative Option to return if this is None
-   * @returns This Option or the alternative
-   */
-  or(alternative: Option<T>): Option<T>
-  /**
-   * Returns the contained value or null if None
-   * @returns The contained value or null
-   */
-  orNull(): T | null
-  /**
-   * Returns the contained value or undefined if None
-   * @returns The contained value or undefined
-   */
-  orUndefined(): T | undefined
-  /**
-   * Maps the value inside the Option using the provided function
-   * @param f - The mapping function
-   * @returns A new Option containing the mapped value, or None if this Option is None
-   */
-  map<U extends Type>(f: (value: T) => U): Option<U>
-  /**
-   * Applies a wrapped function to a wrapped value (Applicative pattern)
-   * @param ff - An Option containing a function from T to U
-   * @returns A new Option containing the result of applying the function
-   */
-  ap<U extends Type>(ff: Option<(value: T) => U>): Option<U>
-  /**
-   * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
-   * @param predicate - The predicate function to test the value
-   * @returns This Option or None
-   */
-  filter(predicate: (value: T) => boolean): Option<T>
-  /**
-   * Maps the value using a function that returns an Option
-   * @param f - The mapping function returning an Option
-   * @returns The result of applying f to the contained value, or None if this Option is None
-   */
-  flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>
-  /**
-   * Maps the value using an async function that returns an Option
-   * @param f - The async mapping function returning an Option
-   * @returns Promise of the result of applying f to the contained value, or None if this Option is None
-   */
-  flatMapAsync<U extends Type>(f: (value: T) => Promise<Option<U>>): Promise<Option<U>>
-  /**
-   * Applies a binary operator to a start value and the contained value
-   * @param f - The binary operator
-   * @returns The result of the reduction
-   */
-  reduce<U>(f: (acc: U, value: T) => U): U
-  /**
-   * Applies a binary operator to the contained value and a start value
-   * @param f - The binary operator
-   * @returns The result of the reduction
-   */
-  reduceRight<U>(f: (acc: U, value: T) => U): U
-  /**
-   * Pattern matches over the Option, applying onNone if None and onSome if Some
-   * @param onNone - Function to apply if the Option is None
-   * @param onSome - Function to apply if the Option has a value
-   * @returns The result of applying the appropriate function
-   */
-  fold<U>(onNone: () => U, onSome: (value: T) => U): U
-  /**
-   * Left-associative fold using the provided zero value and operation
-   * @param z - Zero/identity value
-   * @returns A function that takes an operation to apply
-   */
-  foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B
-  /**
-   * Right-associative fold using the provided zero value and operation
-   * @param z - Zero/identity value
-   * @returns A function that takes an operation to apply
-   */
-  foldRight<B>(z: B): (op: (a: T, b: B) => B) => B
-  /**
-   * Converts this Option to a List
-   * @returns A List containing the value if Some, or empty List if None
-   */
-  toList(): List<T>
-  /**
-   * Checks if this Option contains the specified value
-   * @param value - The value to check for
-   * @returns true if this Option contains the value, false otherwise
-   */
-  contains(value: T): boolean
-  /** The number of elements in this Option (0 or 1) */
-  size: number
-  /**
-   * Converts this Option to an Either
-   * @param left - The value to use for Left if this Option is None
-   * @returns Either.Right with the contained value if Some, or Either.Left with left if None
-   */
-  toEither<E>(left: E): Either<E, T>
-  /**
-   * Returns a string representation of this Option
-   * @returns A string representation
-   */
-  toString(): string
-  /**
-   * Returns a simple object representation of this Option
-   * @returns An object with _tag and value properties
-   */
-  toValue(): { _tag: "Some" | "None"; value: T }
-  /**
-   * Pattern matches over the Option, applying a handler function based on the variant
-   * @param patterns - Object with handler functions for Some and None variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R>(patterns: { Some: (value: T) => R; None: () => R }): R
-}`,Either:`export interface Either<L extends Type, R extends Type>
-  extends FunctypeBase<R, "Left" | "Right">, Promisable<R>, Doable<R>, Reshapeable<R>, Extractable<R> {
-  readonly _tag: "Left" | "Right"
-  value: L | R
-  isLeft(): this is Either<L, R> & { readonly _tag: "Left"; value: L }
-  isRight(): this is Either<L, R> & { readonly _tag: "Right"; value: R }
-  orElse: (defaultValue: R) => R
-  orThrow: (error?: Error) => R
-  or(alternative: Either<L, R>): Either<L, R>
-  orNull: () => R | null
-  orUndefined: () => R | undefined
-  readonly map: <U extends Type>(f: (value: R) => U) => Either<L, U>
-  ap: <U extends Type>(ff: Either<L, (value: R) => U>) => Either<L, U>
-  merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>
-  mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>
-  flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>
-  flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>) => Promise<Either<L, U>>
-  toOption: () => Option<R>
-  toList: () => List<R>
-  toString: () => string
-  [Symbol.iterator]: () => Iterator<R>
-  yield: () => Generator<R, void, unknown>
-  traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>
-  lazyMap: <U extends Type>(f: (value: R) => U) => Generator<Either<L, U>, void, unknown>
-  tap: (f: (value: R) => void) => Either<L, R>
-  tapLeft: (f: (value: L) => void) => Either<L, R>
-  mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>
-  bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R) => R2) => Either<L2, R2>
-  fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R) => T) => T
-  swap: () => Either<R, L>
-  /**
-   * Pipes the value through the provided function based on whether this is a Left or Right
-   * @param onLeft - The function to apply if this is a Left
-   * @param onRight - The function to apply if this is a Right
-   * @returns The result of applying the appropriate function
-   */
-  pipeEither<U extends Type>(onLeft: (value: L) => U, onRight: (value: R) => U): U
-
-  /**
-   * Pipes the Either value through the provided function
-   * @param f - The function to apply to the value (Left or Right)
-   * @returns The result of applying the function to the value
-   */
-  pipe<U extends Type>(f: (value: L | R) => U): U
-  /**
-   * Pattern matches over the Either, applying a handler function based on the variant
-   * @param patterns - Object with handler functions for Left and Right variants
-   * @returns The result of applying the matching handler function
-   */
-  match<T>(patterns: { Left: (value: L) => T; Right: (value: R) => T }): T
-  /**
-   * Returns the value and tag for inspection
-   */
-  toValue(): { _tag: "Left" | "Right"; value: L | R }
-  /**
-   * Custom JSON serialization that excludes getter properties
-   */
-  toJSON(): { _tag: "Left" | "Right"; value: L | R }
-}`,Try:`export interface Try<T>
-  extends FunctypeBase<T, TypeNames>, Extractable<T>, Pipe<T>, Promisable<T>, Doable<T>, Reshapeable<T> {
-  readonly _tag: TypeNames
-  readonly error: Error | undefined
-  isSuccess(): this is Try<T> & { readonly _tag: "Success"; error: undefined }
-  isFailure(): this is Try<T> & { readonly _tag: "Failure"; error: Error }
-  orElse: (defaultValue: T) => T
-  orThrow: (error?: Error) => T
-  or: (alternative: Try<T>) => Try<T>
-  orNull: () => T | null
-  orUndefined: () => T | undefined
-  toOption: () => Option<T>
-  toEither: <E extends Type>(leftValue: E) => Either<E, T>
-  toList: () => List<T>
-  toTry: () => Try<T>
-  map: <U>(f: (value: T) => U) => Try<U>
-  ap: <U>(ff: Try<(value: T) => U>) => Try<U>
-  flatMap: <U>(f: (value: T) => Try<U>) => Try<U>
-  flatMapAsync: <U>(f: (value: T) => Promise<Try<U>>) => Promise<Try<U>>
-  /**
-   * Pattern matches over the Try, applying onFailure if Failure and onSuccess if Success
-   * @param onFailure - Function to apply if the Try is Failure
-   * @param onSuccess - Function to apply if the Try is Success
-   * @returns The result of applying the appropriate function
-   */
-  fold: <U extends Type>(onFailure: (error: Error) => U, onSuccess: (value: T) => U) => U
-  toString: () => string
-  /**
-   * Pattern matches over the Try, applying a handler function based on the variant
-   * @param patterns - Object with handler functions for Success and Failure variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R>(patterns: { Success: (value: T) => R; Failure: (error: Error) => R }): R
-  toValue(): { _tag: TypeNames; value: T | Error }
-}`,List:`export interface List<A> extends FunctypeCollection<A, "List">, Doable<A>, Reshapeable<A> {
-  readonly length: number
-  readonly [Symbol.iterator]: () => Iterator<A>
-  // Override these to return List instead of FunctypeCollection
-  map: <B>(f: (a: A) => B) => List<B>
-  ap: <B>(ff: List<(value: A) => B>) => List<B>
-  flatMap: <B>(f: (a: A) => Iterable<B>) => List<B>
-  flatMapAsync: <B>(f: (a: A) => PromiseLike<Iterable<B>>) => PromiseLike<List<B>>
-  // Override filter for type guard support
-  filter<S extends A>(predicate: (a: A) => a is S): List<S>
-  filter(predicate: (a: A) => unknown): List<A>
-  filterNot: (p: (a: A) => boolean) => List<A>
-  // List-specific methods
-  /** @internal */
-  filterType: <T extends Typeable<string, unknown>>(tag: string) => List<T & A>
-  remove: (value: A) => List<A>
-  removeAt: (index: number) => List<A>
-  add: (item: A) => List<A>
-  get: (index: number) => Option<A>
-  concat: (other: List<A>) => List<A>
-  take: (n: number) => List<A>
-  takeWhile: (p: (a: A) => boolean) => List<A>
-  takeRight: (n: number) => List<A>
-  get last(): A | undefined
-  get lastOption(): Option<A>
-  get tail(): List<A>
-  get init(): List<A>
-  reverse: () => List<A>
-  indexOf: (value: A) => number
-  prepend: (item: A) => List<A>
-  distinct: () => List<A>
-  sorted: (compareFn?: (a: A, b: A) => number) => List<A>
-  sortBy: <B>(f: (a: A) => B, compareFn?: (a: B, b: B) => number) => List<A>
-  zip: <B>(other: List<B>) => List<[A, B]>
-  zipWithIndex: () => List<[A, number]>
-  groupBy: <K>(f: (a: A) => K) => globalThis.Map<K, List<A>>
-  partition: (p: (a: A) => boolean) => [List<A>, List<A>]
-  span: (p: (a: A) => boolean) => [List<A>, List<A>]
-  slice: (start: number, end: number) => List<A>
-  /**
-   * Pattern matches over the List, applying a handler function based on whether it's empty
-   * @param patterns - Object with handler functions for Empty and NonEmpty variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R
-}`,Set:`export interface Set<A> extends FunctypeCollection<A, "Set">, Collection<A> {
-  add: (value: A) => Set<A>
-  remove: (value: A) => Set<A>
-  contains: (value: A) => boolean
-  has: (value: A) => boolean
-  map: <B>(f: (a: A) => B) => Set<B>
-  flatMap: <B>(f: (a: A) => Iterable<B>) => Set<B>
-  filter: (p: (a: A) => boolean) => Set<A>
-  filterNot: (p: (a: A) => boolean) => Set<A>
-  fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U
-  toList: () => List<A>
-  toSet: () => Set<A>
-  toArray: <B = A>() => B[]
-  toString: () => string
-}`,Map:`export interface Map<K, V>
-  extends
-    SafeTraversable<K, V>,
-    Collection<Tuple<[K, V]>>,
-    Typeable<"Map">,
-    Serializable<[K, V][]>,
-    Pipe<[K, V][]>,
-    Foldable<Tuple<[K, V]>>,
-    Iterable<[K, V]> {
-  readonly _tag: "Map"
-  add(item: Tuple<[K, V]>): Map<K, V>
-  remove(value: K): Map<K, V>
-  map<U>(f: (value: V) => U): Map<K, U>
-  ap<U>(ff: Map<K, (value: V) => U>): Map<K, U>
-  flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => Iterable<[K2, V2]>): Map<K2, V2>
-  flatMapAsync<U>(f: (value: V) => PromiseLike<Map<K, U>>): PromiseLike<Map<K, U>>
-  get(key: K): Option<V>
-  getOrElse(key: K, defaultValue: V): V
-  orElse(key: K, alternative: Option<V>): Option<V>
-  fold<U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K, V]>) => U): U
-  foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K, V]>) => B) => B
-  foldRight<B>(z: B): (op: (a: Tuple<[K, V]>, b: B) => B) => B
-  /**
-   * Pattern matches over the Map, applying a handler function based on whether it's empty
-   * @param patterns - Object with handler functions for Empty and NonEmpty variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R>(patterns: { Empty: () => R; NonEmpty: (entries: Array<Tuple<[K, V]>>) => R }): R
-  toValue(): { _tag: "Map"; value: [K, V][] }
-}`,Lazy:`export interface Lazy<T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<T>, Pipe<T> {
-  /** Tag identifying this as a Lazy type */
-  readonly _tag: "Lazy"
-  /** Whether the computation has been evaluated */
-  readonly isEvaluated: boolean
-  /**
-   * Returns the computed value or a default value if computation fails
-   * @param defaultValue - The value to return if computation fails
-   * @returns The computed value or defaultValue
-   */
-  orElse(defaultValue: T): T
-  /**
-   * Returns the computed value or null if computation fails
-   * @returns The computed value or null
-   */
-  orNull(): T | null
-  /**
-   * Returns the computed value or throws an error if computation fails
-   * @param error - Optional custom error to throw. If not provided, throws the computation error or a default error
-   * @returns The computed value
-   * @throws The specified error, computation error, or a default error
-   */
-  orThrow(error?: Error): T
-  /**
-   * Returns this Lazy if computation succeeds, otherwise returns the alternative Lazy
-   * @param alternative - The alternative Lazy to use if computation fails
-   * @returns This Lazy or the alternative
-   */
-  or(alternative: Lazy<T>): Lazy<T>
-  /**
-   * Maps the value inside the Lazy using the provided function
-   * @param f - The mapping function
-   * @returns A new Lazy containing the mapped value
-   */
-  map<U extends Type>(f: (value: T) => U): Lazy<U>
-  /**
-   * Applies a wrapped function to a wrapped value (Applicative pattern)
-   * @param ff - A Lazy containing a function from T to U
-   * @returns A new Lazy containing the result
-   */
-  ap<U extends Type>(ff: Lazy<(value: T) => U>): Lazy<U>
-  /**
-   * Maps the value inside the Lazy using an async function
-   * @param f - The async mapping function
-   * @returns A Promise of a new Lazy containing the mapped value
-   */
-  mapAsync<U extends Type>(f: (value: T) => Promise<U>): Promise<Lazy<U>>
-  /**
-   * Maps the value using a function that returns a Lazy
-   * @param f - The mapping function returning a Lazy
-   * @returns A new Lazy containing the flattened result
-   */
-  flatMap<U extends Type>(f: (value: T) => Lazy<U>): Lazy<U>
-  /**
-   * Maps the value using an async function that returns a Lazy
-   * @param f - The async mapping function returning a Lazy
-   * @returns A Promise of a new Lazy containing the flattened result
-   */
-  flatMapAsync<U extends Type>(f: (value: T) => Promise<Lazy<U>>): Promise<Lazy<U>>
-  /**
-   * Returns a Lazy that filters the value based on a predicate
-   * @param predicate - The predicate function
-   * @returns A Lazy containing an Option of the value
-   */
-  filter(predicate: (value: T) => boolean): Lazy<Option<T>>
-  /**
-   * Recovers from a failed computation by providing an alternative value
-   * @param f - Function that takes the error and returns a recovery value
-   * @returns A new Lazy that will use the recovery function if computation fails
-   */
-  recover(f: (error: unknown) => T): Lazy<T>
-  /**
-   * Recovers from a failed computation by providing an alternative Lazy
-   * @param f - Function that takes the error and returns a recovery Lazy
-   * @returns A new Lazy that will use the recovery Lazy if computation fails
-   */
-  recoverWith(f: (error: unknown) => Lazy<T>): Lazy<T>
-  /**
-   * Evaluates the computation and returns it as an Option
-   * @returns Some containing the value if successful, None if computation fails
-   */
-  toOption(): Option<T>
-  /**
-   * Evaluates the computation and returns it as an Either
-   * @returns Right containing the value if successful, Left containing the error if computation fails
-   */
-  toEither(): Either<unknown, T>
-  /**
-   * Evaluates the computation and returns it as an Either with a mapped error
-   * @param mapError - Function to map the error
-   * @returns Right containing the value if successful, Left containing the mapped error if computation fails
-   */
-  toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T>
-  /**
-   * Evaluates the computation and returns it as a Try
-   * @returns Try containing the result of the computation
-   */
-  toTry(): Try<T>
-  /**
-   * Applies an effect function to the value if computation succeeds
-   * @param f - The effect function
-   * @returns This Lazy for chaining
-   */
-  tap(f: (value: T) => void): Lazy<T>
-  /**
-   * Applies an effect function to the error if computation fails
-   * @param f - The effect function for errors
-   * @returns This Lazy for chaining
-   */
-  tapError(f: (error: unknown) => void): Lazy<T>
-  /**
-   * Pattern matching on the Lazy value
-   * @param f - Function to apply to the computed value
-   * @returns The result of applying f to the computed value
-   */
-  fold<U>(f: (value: T) => U): U
-  /**
-   * Pattern matching with success and failure handlers
-   * @param onFailure - Function to handle computation failure
-   * @param onSuccess - Function to handle successful computation
-   * @returns The result of the appropriate handler
-   */
-  foldWith<U>(onFailure: (error: unknown) => U, onSuccess: (value: T) => U): U
-  /**
-   * Left fold operation
-   * @param z - Initial value
-   * @returns Function that takes an operator and applies it
-   */
-  foldLeft: <B>(z: B) => (op: (b: B, a: T) => B) => B
-  /**
-   * Right fold operation
-   * @param z - Initial value
-   * @returns Function that takes an operator and applies it
-   */
-  foldRight: <B>(z: B) => (op: (a: T, b: B) => B) => B
-  /**
-   * Pattern matching for the Lazy type
-   * @param patterns - Object with handler for Lazy pattern
-   * @returns The result of the matched handler
-   */
-  match<R>(patterns: { Lazy: (value: T) => R }): R
-  /**
-   * Creates a string representation of the Lazy
-   * @returns String representation showing evaluation status
-   */
-  toString(): string
-  /**
-   * Converts the Lazy to a value object
-   * @returns Object representation of the Lazy with evaluation state
-   */
-  toValue(): { _tag: "Lazy"; evaluated: boolean; value?: T }
-}`,LazyList:`export interface LazyList<A extends Type>
-  extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<"LazyList"> {
-  // Iterator protocol
-  [Symbol.iterator](): Iterator<A>
-
-  // Lazy operations
-  map<B extends Type>(f: (a: A) => B): LazyList<B>
-  flatMap<B extends Type>(f: (a: A) => LazyList<B>): LazyList<B>
-  filter(predicate: (a: A) => boolean): LazyList<A>
-  take(n: number): LazyList<A>
-  drop(n: number): LazyList<A>
-  takeWhile(predicate: (a: A) => boolean): LazyList<A>
-  dropWhile(predicate: (a: A) => boolean): LazyList<A>
-  concat(other: LazyList<A>): LazyList<A>
-  zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>
-
-  takeRight(n: number): LazyList<A>
-  reverse(): LazyList<A>
-  distinct(): LazyList<A>
-  zipWithIndex(): LazyList<[A, number]>
-
-  // Element access (properties)
-  get head(): A | undefined
-  get headOption(): Option<A>
-  get last(): A | undefined
-  get lastOption(): Option<A>
-  get tail(): LazyList<A>
-  get init(): LazyList<A>
-
-  // Terminal operations (force evaluation)
-  toList(): List<A>
-  toArray(): A[]
-  forEach(f: (a: A) => void): void
-  reduce<B extends Type>(f: (acc: B, a: A) => B, initial: B): B
-  find(predicate: (a: A) => boolean): Option<A>
-  some(predicate: (a: A) => boolean): boolean
-  every(predicate: (a: A) => boolean): boolean
-  count(): number
-
-  // Additional methods for clarity
-  toString(): string
-}`,TaskOutcome:`export interface TaskOutcome<T>
-  extends FunctypeBase<T, "Ok" | "Err">, Extractable<T>, AsyncMonad<T>, Promisable<T>, Doable<T> {
-  readonly _tag: "Ok" | "Err"
-  readonly _meta: TaskMetadata
-
-  // Value access
-  readonly value?: T
-  readonly error?: Throwable
-
-  // Functional methods
-  readonly map: <U>(f: (value: T) => U) => TaskOutcome<U>
-  readonly flatMap: <U>(f: (value: T) => TaskOutcome<U> | Either<Throwable, U>) => TaskOutcome<U>
-  readonly ap: <U>(ff: TaskOutcome<(value: T) => U>) => TaskOutcome<U>
-  readonly mapAsync: <U>(f: (value: T) => Promise<U>) => Promise<TaskOutcome<U>>
-  readonly flatMapAsync: <U>(f: (value: T) => Promise<TaskOutcome<U>>) => Promise<TaskOutcome<U>>
-
-  // Error handling methods
-  readonly mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T>
-  readonly recover: (value: T) => Ok<T>
-  readonly recoverWith: (f: (error: Throwable) => T) => Ok<T>
-
-  // Type guards
-  readonly isSuccess: () => this is Ok<T>
-  readonly isFailure: () => this is Err<T>
-  readonly isOk: () => this is Ok<T>
-  readonly isErr: () => this is Err<T>
-
-  // Conversion methods
-  readonly toEither: () => Either<Throwable, T>
-  readonly toTry: () => Try<T>
-  readonly toOption: () => Option<T>
-  readonly toList: () => List<T>
-
-  // Pattern matching
-  readonly fold: <U>(onErr: (error: Throwable) => U, onOk: (value: T) => U) => U
-  readonly match: <U>(patterns: { Ok: (value: T) => U; Err: (error: Throwable) => U }) => U
-}`,Tuple:`export interface Tuple<T extends Type[]>
-  extends Foldable<T[number]>, Pipe<Tuple<T>>, Serializable<Tuple<T>>, Typeable<"Tuple"> {
-  get<K extends number>(index: K): T[K]
-
-  map<U extends Type[]>(f: (value: T) => U): Tuple<U>
-
-  flatMap<U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U>
-
-  toArray(): T
-
-  length: number
-
-  [Symbol.iterator](): Iterator<T[number]>
-
-  toString(): string
-
-  toValue(): { _tag: "Tuple"; value: T }
-}`,Stack:`export type Stack<A extends Type> = {
-  /**
-   * Push a value onto the top of the stack
-   * @param value - The value to push
-   * @returns A new Stack with the value added
-   */
-  push(value: A): Stack<A>
-
-  /**
-   * Remove and return the top value from the stack
-   * @returns A tuple containing the new Stack and the value
-   */
-  pop(): [Stack<A>, Option<A>]
-
-  /**
-   * Return the top value without removing it
-   * @returns The top value wrapped in an Option
-   */
-  peek(): Option<A>
-
-  /**
-   * Transforms each element in the stack using the provided function
-   * @param f - The mapping function
-   * @returns A new Stack with transformed elements
-   */
-  map<B extends Type>(f: (a: A) => B): Stack<B>
-
-  /**
-   * Maps each element to a Stack and flattens the result
-   * @param f - The mapping function returning a Stack
-   * @returns A new flattened Stack
-   */
-  flatMap<B extends Type>(f: (a: A) => Stack<B>): Stack<B>
-
-  /**
-   * Applies a Stack of functions to this Stack
-   * @param ff - Stack of functions to apply
-   * @returns A new Stack with applied functions
-   */
-  ap<B extends Type>(ff: Stack<(value: A) => B>): Stack<B>
-
-  /**
-   * Maps each element to an async Stack and flattens the result
-   * @param f - The async mapping function returning a Stack
-   * @returns A promise of the new flattened Stack
-   */
-  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Stack<B>>): PromiseLike<Stack<B>>
-
-  /**
-   * Convert the stack to a List
-   * @returns A List containing all elements
-   */
-  toList(): List<A>
-
-  /**
-   * Convert the stack to an array
-   * @returns An array of all elements
-   */
-  toArray(): A[]
-
-  /**
-   * Returns a string representation of the stack
-   * @returns A string representation
-   */
-  toString(): string
-
-  /**
-   * Pattern matches over the Stack, applying a handler function based on whether it's empty
-   * @param patterns - Object with handler functions for Empty and NonEmpty variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R
-} & Traversable<A> &`},g=e=>{let t=n(e.slice(2));return{flags:{json:t.contains(`--json`),full:t.contains(`--full`),help:t.exists(e=>e===`--help`||e===`-h`)},args:t.filter(e=>!e.startsWith(`--`)&&e!==`-h`)}},_=e=>t(h[e]).or(n(Object.entries(h)).find(([t])=>t.toLowerCase()===e.toLowerCase()).map(([,e])=>e)),v=()=>{let e=n([`FULL INTERFACE DEFINITIONS`,`=`.repeat(60),``]);return n(Object.entries(h)).foldLeft(e)((e,[t,r])=>e.concat(n([`// ${t}`,r,``,`-`.repeat(60),``]))).toArray().join(`
+import{P as e}from"../Valuable-DeccMyYD.js";import{Option as t}from"../option/index.js";import{List as n}from"../list/index.js";import{a as r,i,n as a,r as o,t as s}from"../full-interfaces-D7DbT-2A.js";const c=()=>{let e=n([`functype ${r} - Scala-inspired FP for TypeScript`,``]);return n(Object.entries(a)).foldLeft(e)((e,[r,a])=>{let o=e.add(r.toUpperCase());return n(a).foldLeft(o)((e,n)=>t(i[n]).fold(()=>e,t=>{let r=t.interfaces.length>0?` [${t.interfaces.join(`, `)}]`:``;return e.add(`  ${n}${r}`).add(`    ${t.description}`)})).add(``)}).concat(n([`Use: npx functype <Type> for details`,`Use: npx functype interfaces for interface reference`])).toArray().join(`
+`)},l=(e,r)=>{let i=r.interfaces.length>0?` [${r.interfaces.join(`, `)}]`:``,a=n([`create`,`transform`,`extract`,`check`,`other`]),o=n([`${e}<T>${i}`,``,r.description,``]);return a.foldLeft(o)((e,i)=>t(r.methods[i]).filter(e=>e.length>0).fold(()=>e,t=>{let r=e.add(i.toUpperCase());return n(t).foldLeft(r)((e,t)=>e.add(`  ${t}`)).add(``)})).toArray().join(`
+`).trimEnd()},u=()=>{let e=n([`INTERFACES`,``]);return n(Object.entries(o)).foldLeft(e)((e,[t,r])=>{let i=r.extends?` extends ${r.extends}`:``,a=e.add(`${t}<A>${i}`).add(`  ${r.description}`);return n(r.methods).foldLeft(a)((e,t)=>e.add(`  ${t}`)).add(``)}).toArray().join(`
+`).trimEnd()},d=e=>JSON.stringify(e,null,2),f=()=>({version:r,categories:a,types:i}),p=e=>t(i[e]).map(t=>({name:e,data:t})).or(n(Object.entries(i)).find(([t])=>t.toLowerCase()===e.toLowerCase()).map(([e,t])=>({name:e,data:t}))).orUndefined(),m=()=>Object.keys(i),h=()=>o,g=e=>{let t=n(e.slice(2));return{flags:{json:t.contains(`--json`),full:t.contains(`--full`),help:t.exists(e=>e===`--help`||e===`-h`)},args:t.filter(e=>!e.startsWith(`--`)&&e!==`-h`)}},_=e=>t(s[e]).or(n(Object.entries(s)).find(([t])=>t.toLowerCase()===e.toLowerCase()).map(([,e])=>e)),v=()=>{let e=n([`FULL INTERFACE DEFINITIONS`,`=`.repeat(60),``]);return n(Object.entries(s)).foldLeft(e)((e,[t,r])=>e.concat(n([`// ${t}`,r,``,`-`.repeat(60),``]))).toArray().join(`
 `).trimEnd()},y=()=>{console.log(`functype - API documentation for LLMs
 
 USAGE
@@ -661,4 +24,4 @@ EXAMPLES
   npx functype Option --json # Option as JSON
   npx functype Option --full # Full TypeScript interface
   npx functype --full       # All full interfaces (large output!)
-`)},b=e=>{console.error(`Unknown type: ${e}`),console.error(``),console.error(`Available types: ${p().join(`, `)}`),console.error(``),console.error(`Use: npx functype interfaces - for interface reference`),process.exit(1)},x=e=>console.log(e),S=(e,n)=>t(f(e)).fold(()=>b(e),e=>{n.full?_(e.name).fold(()=>x(n.json?u({[e.name]:e.data}):c(e.name,e.data)),t=>x(n.json?u({[e.name]:{...e.data,fullInterface:t}}):t)):x(n.json?u({[e.name]:e.data}):c(e.name,e.data))});(()=>{let{flags:t,args:n}=g(process.argv);e(!0).when(()=>t.help,()=>y()).when(()=>n.isEmpty,()=>t.full?x(t.json?u(h):v()):x(t.json?u(d()):s())).when(()=>n.headOption.contains(`interfaces`),()=>x(t.json?u(m()):l())).default(()=>n.headOption.fold(()=>x(t.json?u(d()):s()),e=>S(e,t)))})();
+`)},b=e=>{console.error(`Unknown type: ${e}`),console.error(``),console.error(`Available types: ${m().join(`, `)}`),console.error(``),console.error(`Use: npx functype interfaces - for interface reference`),process.exit(1)},x=e=>console.log(e),S=(e,n)=>t(p(e)).fold(()=>b(e),e=>{n.full?_(e.name).fold(()=>x(n.json?d({[e.name]:e.data}):l(e.name,e.data)),t=>x(n.json?d({[e.name]:{...e.data,fullInterface:t}}):t)):x(n.json?d({[e.name]:e.data}):l(e.name,e.data))});(()=>{let{flags:t,args:n}=g(process.argv);e(!0).when(()=>t.help,()=>y()).when(()=>n.isEmpty,()=>t.full?x(t.json?d(s):v()):x(t.json?d(f()):c())).when(()=>n.headOption.contains(`interfaces`),()=>x(t.json?d(h()):u())).default(()=>n.headOption.fold(()=>x(t.json?d(f()):c()),e=>S(e,t)))})();