@nlozgachev/pipelined 0.54.0 → 0.55.0

package/dist/{InternalTypes-CDiDBAY4.d.mts → InternalTypes-DuK_XpTi.d.cts}

@@ -1,4 +1,4 @@
-import { D as Duration } from './Duration-B8joKzro.mjs';
+import { D as Duration } from './Duration-B8joKzro.cjs';
 
 declare const _deferred: unique symbol;
 /**

package/dist/{Validation-C5Qz1R0S.d.mts → Validation-CbU7Z-kj.d.cts}

@@ -1,6 +1,6 @@
-import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, T as Thenable, D as Deferred, f as WithErrors } from './InternalTypes-CDiDBAY4.mjs';
-import { D as Duration } from './Duration-B8joKzro.mjs';
-import { RetryPolicy } from './types.mjs';
+import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, T as Thenable, D as Deferred, f as WithErrors } from './InternalTypes-DuK_XpTi.cjs';
+import { D as Duration } from './Duration-B8joKzro.cjs';
+import { RetryPolicy } from './types.cjs';
 
 /**
  * A function that checks whether two values of type `A` are equal.
@@ -595,13 +595,16 @@ declare namespace Result {
      * Creates a Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
      *
+    /**
+     * Creates a Result from a synchronous thunk that may throw.
+     * Catches any errors and transforms them using the `onError` function.
+     *
      * @example
      * ```ts
-     * const parseJson = (s: string): Result<string, unknown> =>
-     *   Result.tryCatch(
-     *     () => JSON.parse(s),
-     *     { onError: (e) => `Parse error: ${e}` }
-     *   );
+     * const result = Result.tryCatch(
+     *   () => JSON.parse(rawString),
+     *   { onError: (e) => `Parse error: ${e}` }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: () => A, options: {
@@ -749,24 +752,6 @@ declare namespace Result {
          * ```
          */
         const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Result<E, A>;
-        /**
-         * Wraps a throwing function of any arguments, returning a new function
-         * that catches errors and returns a Result.
-         *
-         * @example
-         * ```ts
-         * const safeParse = Result.from.throwable(
-         *   (s: string) => JSON.parse(s),
-         *   { onError: (e) => new Error(`Parse error: ${e}`) }
-         * );
-         *
-         * safeParse('{"a":1}'); // Ok({ a: 1 })
-         * safeParse('invalid');  // Err(Error)
-         * ```
-         */
-        const throwable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => A, options: {
-            onError: (e: unknown) => E;
-        }) => (...args: Args) => Result<E, A>;
         /**
          * Converts a `Validation` to a `Result`, combining accumulated errors using `combineErrors`.
          * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
@@ -1159,7 +1144,7 @@ declare namespace TaskResult {
          * const res = await task(); // Ok(42)
          * ```
          */
-        const ok: <E, A>(value: A) => TaskResult<E, A>;
+        const ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
         /**
          * Creates a failed Task.Result with the given error.
          *
@@ -1169,10 +1154,10 @@ declare namespace TaskResult {
          * const res = await task(); // Err("failed")
          * ```
          */
-        const err: <E, A>(error: E) => TaskResult<E, A>;
+        const err: <E, A = never>(error: E) => TaskResult<E, A>;
     }
-    const ok: <E, A>(value: A) => TaskResult<E, A>;
-    const err: <E, A>(error: E) => TaskResult<E, A>;
+    const ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
+    const err: <E, A = never>(error: E) => TaskResult<E, A>;
     namespace from {
         /**
          * Creates a Task.Result from a nullable value.
@@ -1204,14 +1189,15 @@ declare namespace TaskResult {
          * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
          * ```
          */
-        const Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
         /**
-         * Wraps a Promise-returning function of any arguments, returning a new function
-         * that catches rejections and returns a Task.Result.
+         * Lifts a Result into a Task.Result.
+         *
+         * @example
+         * ```ts
+         * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
+         * ```
          */
-        const throwable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, options: {
-            onError: (e: unknown) => E;
-        }) => (...args: Args) => TaskResult<E, A>;
+        const Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
     }
     namespace to {
         /**
@@ -1226,21 +1212,20 @@ declare namespace TaskResult {
         const Maybe: <E, A>(data: TaskResult<E, A>) => TaskMaybe<A>;
     }
     /**
-     * Creates a Task.Result from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
+     * Creates a Task.Result from a Promise-returning thunk that may throw or reject.
+     * Catches any errors and transforms them using the `onError` function into an `Err`.
+     * The thunk optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): Task.Result<string, User> =>
-     *   Task.Result.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     { onError: String }
-     *   );
+     * const loadUser = Task.Result.tryCatch(
+     *   (signal) => userStore.get("u_123", { signal }),
+     *   { onError: (e) => new DbError(e) }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-        onError: (e: unknown) => E;
+        onError: (error: unknown) => E;
     }) => TaskResult<E, A>;
     /**
      * Transforms the success value inside a Task.Result.
@@ -1436,7 +1421,7 @@ declare namespace TaskValidation {
          * const res = await task(); // Passed(42)
          * ```
          */
-        const passed: <E, A>(value: A) => TaskValidation<E, A>;
+        const passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
         /**
          * Creates a failed Task.Validation with a single error.
          *
@@ -1446,7 +1431,7 @@ declare namespace TaskValidation {
          * const res = await task(); // Failed(["invalid"])
          * ```
          */
-        const failed: <E, A>(error: E) => TaskValidation<E, A>;
+        const failed: <E, A = never>(error: E) => TaskValidation<E, A>;
         /**
          * Creates a failed Task.Validation from multiple errors.
          *
@@ -1456,11 +1441,11 @@ declare namespace TaskValidation {
          * const res = await task(); // Failed(["err1", "err2"])
          * ```
          */
-        const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+        const failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
     }
-    const passed: <E, A>(value: A) => TaskValidation<E, A>;
-    const failed: <E, A>(error: E) => TaskValidation<E, A>;
-    const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+    const passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
+    const failed: <E, A = never>(error: E) => TaskValidation<E, A>;
+    const failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
     namespace from {
         /**
          * Lifts a Validation into a Task.Validation.
@@ -1510,17 +1495,22 @@ declare namespace TaskValidation {
      * Creates a Task.Validation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
      * The factory optionally receives an `AbortSignal` forwarded from the call site.
+    /**
+     * Creates a Task.Validation from a Promise-returning thunk that may throw or reject.
+     * Catches any errors and transforms them using the `onError` function into a Failed validation.
+     * The thunk optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): Task.Validation<string, User> =>
-     *   Task.Validation.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     e => `Failed to fetch user: ${e}`
-     *   );
+     * const loadConfig = Task.Validation.tryCatch(
+     *   (signal) => configStore.get("default", { signal }),
+     *   { onError: (e) => `Failed to load config: ${e}` }
+     * );
      * ```
      */
-    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
+    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+        onError: (error: unknown) => E;
+    }) => TaskValidation<E, A>;
     /**
      * Transforms the success value inside a Task.Validation.
      */
@@ -1701,16 +1691,6 @@ declare namespace Task {
      */
     const resolve: <A>(value: A) => Task<A>;
     namespace from {
-        /**
-         * Creates a Task from a function that returns a Promise.
-         * The factory optionally receives an `AbortSignal` forwarded from the call site.
-         *
-         * @example
-         * ```ts
-         * const getTimestamp = Task.from.Promise(() => Promise.resolve(Date.now()));
-         * ```
-         */
-        const Promise: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task<A>;
         /**
          * Creates a Task from a lazy synchronous thunk.
          * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
@@ -1723,6 +1703,21 @@ declare namespace Task {
          */
         const sync: <A>(f: () => A) => Task<A>;
     }
+    /**
+     * Wraps a Promise-returning thunk that may throw or reject,
+     * trapping errors with a fallback function and returning a guaranteed `Task<A>`.
+     *
+     * @example
+     * ```ts
+     * const loadConfig = Task.tryCatch(
+     *   () => configStore.get("default"),
+     *   { onError: () => DEFAULT_CONFIG }
+     * );
+     * ```
+     */
+    const tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
+        onError: (error: unknown) => A;
+    }) => Task<A>;
     /**
      * Transforms the value inside a Task.
      *
@@ -1845,8 +1840,8 @@ declare namespace Task {
      *
      * @example
      * ```ts
-     * const fast = Task.from.Promise(() => new Promise<string>(r => setTimeout(() => r("fast"), 10)));
-     * const slow = Task.from.Promise(() => new Promise<string>(r => setTimeout(() => r("slow"), 200)));
+     * const fast = Task.resolve("fast");
+     * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
      *
      * await Task.race([fast, slow])(); // "fast"
      * ```
@@ -1870,10 +1865,7 @@ declare namespace Task {
      * @example
      * ```ts
      * let log: number[] = [];
-     * const makeTask = (n: number) => Task.from.Promise(() => {
-     *   log.push(n);
-     *   return Promise.resolve(n);
-     * });
+     * const makeTask = (n: number) => Task.resolve(n);
      *
      * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
      * // log = [1, 2, 3] — tasks ran in order
@@ -2089,16 +2081,15 @@ declare namespace Validation {
         const failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
     }
     /**
-     * Creates a Validation from a function that may throw.
-     * Catches any errors and transforms them using the onError function into a Failed validation.
+     * Creates a Validation from a synchronous thunk that may throw.
+     * Catches any errors and transforms them using the `onError` function into a Failed validation.
      *
      * @example
      * ```ts
-     * const parseJson = (s: string): Validation<string, unknown> =>
-     *   Validation.tryCatch(
-     *     () => JSON.parse(s),
-     *     { onError: (e) => `Parse error: ${e}` }
-     *   );
+     * const result = Validation.tryCatch(
+     *   () => JSON.parse(rawString),
+     *   { onError: (e) => `Parse error: ${e}` }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: () => A, options: {

package/dist/{Validation-yOcgYn9K.d.ts → Validation-CmxZ3V4r.d.ts}

@@ -595,13 +595,16 @@ declare namespace Result {
      * Creates a Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
      *
+    /**
+     * Creates a Result from a synchronous thunk that may throw.
+     * Catches any errors and transforms them using the `onError` function.
+     *
      * @example
      * ```ts
-     * const parseJson = (s: string): Result<string, unknown> =>
-     *   Result.tryCatch(
-     *     () => JSON.parse(s),
-     *     { onError: (e) => `Parse error: ${e}` }
-     *   );
+     * const result = Result.tryCatch(
+     *   () => JSON.parse(rawString),
+     *   { onError: (e) => `Parse error: ${e}` }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: () => A, options: {
@@ -749,24 +752,6 @@ declare namespace Result {
          * ```
          */
         const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Result<E, A>;
-        /**
-         * Wraps a throwing function of any arguments, returning a new function
-         * that catches errors and returns a Result.
-         *
-         * @example
-         * ```ts
-         * const safeParse = Result.from.throwable(
-         *   (s: string) => JSON.parse(s),
-         *   { onError: (e) => new Error(`Parse error: ${e}`) }
-         * );
-         *
-         * safeParse('{"a":1}'); // Ok({ a: 1 })
-         * safeParse('invalid');  // Err(Error)
-         * ```
-         */
-        const throwable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => A, options: {
-            onError: (e: unknown) => E;
-        }) => (...args: Args) => Result<E, A>;
         /**
          * Converts a `Validation` to a `Result`, combining accumulated errors using `combineErrors`.
          * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
@@ -1159,7 +1144,7 @@ declare namespace TaskResult {
          * const res = await task(); // Ok(42)
          * ```
          */
-        const ok: <E, A>(value: A) => TaskResult<E, A>;
+        const ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
         /**
          * Creates a failed Task.Result with the given error.
          *
@@ -1169,10 +1154,10 @@ declare namespace TaskResult {
          * const res = await task(); // Err("failed")
          * ```
          */
-        const err: <E, A>(error: E) => TaskResult<E, A>;
+        const err: <E, A = never>(error: E) => TaskResult<E, A>;
     }
-    const ok: <E, A>(value: A) => TaskResult<E, A>;
-    const err: <E, A>(error: E) => TaskResult<E, A>;
+    const ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
+    const err: <E, A = never>(error: E) => TaskResult<E, A>;
     namespace from {
         /**
          * Creates a Task.Result from a nullable value.
@@ -1204,14 +1189,15 @@ declare namespace TaskResult {
          * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
          * ```
          */
-        const Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
         /**
-         * Wraps a Promise-returning function of any arguments, returning a new function
-         * that catches rejections and returns a Task.Result.
+         * Lifts a Result into a Task.Result.
+         *
+         * @example
+         * ```ts
+         * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
+         * ```
          */
-        const throwable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, options: {
-            onError: (e: unknown) => E;
-        }) => (...args: Args) => TaskResult<E, A>;
+        const Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
     }
     namespace to {
         /**
@@ -1226,21 +1212,20 @@ declare namespace TaskResult {
         const Maybe: <E, A>(data: TaskResult<E, A>) => TaskMaybe<A>;
     }
     /**
-     * Creates a Task.Result from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
+     * Creates a Task.Result from a Promise-returning thunk that may throw or reject.
+     * Catches any errors and transforms them using the `onError` function into an `Err`.
+     * The thunk optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): Task.Result<string, User> =>
-     *   Task.Result.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     { onError: String }
-     *   );
+     * const loadUser = Task.Result.tryCatch(
+     *   (signal) => userStore.get("u_123", { signal }),
+     *   { onError: (e) => new DbError(e) }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-        onError: (e: unknown) => E;
+        onError: (error: unknown) => E;
     }) => TaskResult<E, A>;
     /**
      * Transforms the success value inside a Task.Result.
@@ -1436,7 +1421,7 @@ declare namespace TaskValidation {
          * const res = await task(); // Passed(42)
          * ```
          */
-        const passed: <E, A>(value: A) => TaskValidation<E, A>;
+        const passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
         /**
          * Creates a failed Task.Validation with a single error.
          *
@@ -1446,7 +1431,7 @@ declare namespace TaskValidation {
          * const res = await task(); // Failed(["invalid"])
          * ```
          */
-        const failed: <E, A>(error: E) => TaskValidation<E, A>;
+        const failed: <E, A = never>(error: E) => TaskValidation<E, A>;
         /**
          * Creates a failed Task.Validation from multiple errors.
          *
@@ -1456,11 +1441,11 @@ declare namespace TaskValidation {
          * const res = await task(); // Failed(["err1", "err2"])
          * ```
          */
-        const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+        const failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
     }
-    const passed: <E, A>(value: A) => TaskValidation<E, A>;
-    const failed: <E, A>(error: E) => TaskValidation<E, A>;
-    const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+    const passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
+    const failed: <E, A = never>(error: E) => TaskValidation<E, A>;
+    const failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
     namespace from {
         /**
          * Lifts a Validation into a Task.Validation.
@@ -1510,17 +1495,22 @@ declare namespace TaskValidation {
      * Creates a Task.Validation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
      * The factory optionally receives an `AbortSignal` forwarded from the call site.
+    /**
+     * Creates a Task.Validation from a Promise-returning thunk that may throw or reject.
+     * Catches any errors and transforms them using the `onError` function into a Failed validation.
+     * The thunk optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): Task.Validation<string, User> =>
-     *   Task.Validation.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     e => `Failed to fetch user: ${e}`
-     *   );
+     * const loadConfig = Task.Validation.tryCatch(
+     *   (signal) => configStore.get("default", { signal }),
+     *   { onError: (e) => `Failed to load config: ${e}` }
+     * );
      * ```
      */
-    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
+    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+        onError: (error: unknown) => E;
+    }) => TaskValidation<E, A>;
     /**
      * Transforms the success value inside a Task.Validation.
      */
@@ -1701,16 +1691,6 @@ declare namespace Task {
      */
     const resolve: <A>(value: A) => Task<A>;
     namespace from {
-        /**
-         * Creates a Task from a function that returns a Promise.
-         * The factory optionally receives an `AbortSignal` forwarded from the call site.
-         *
-         * @example
-         * ```ts
-         * const getTimestamp = Task.from.Promise(() => Promise.resolve(Date.now()));
-         * ```
-         */
-        const Promise: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task<A>;
         /**
          * Creates a Task from a lazy synchronous thunk.
          * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
@@ -1723,6 +1703,21 @@ declare namespace Task {
          */
         const sync: <A>(f: () => A) => Task<A>;
     }
+    /**
+     * Wraps a Promise-returning thunk that may throw or reject,
+     * trapping errors with a fallback function and returning a guaranteed `Task<A>`.
+     *
+     * @example
+     * ```ts
+     * const loadConfig = Task.tryCatch(
+     *   () => configStore.get("default"),
+     *   { onError: () => DEFAULT_CONFIG }
+     * );
+     * ```
+     */
+    const tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
+        onError: (error: unknown) => A;
+    }) => Task<A>;
     /**
      * Transforms the value inside a Task.
      *
@@ -1845,8 +1840,8 @@ declare namespace Task {
      *
      * @example
      * ```ts
-     * const fast = Task.from.Promise(() => new Promise<string>(r => setTimeout(() => r("fast"), 10)));
-     * const slow = Task.from.Promise(() => new Promise<string>(r => setTimeout(() => r("slow"), 200)));
+     * const fast = Task.resolve("fast");
+     * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
      *
      * await Task.race([fast, slow])(); // "fast"
      * ```
@@ -1870,10 +1865,7 @@ declare namespace Task {
      * @example
      * ```ts
      * let log: number[] = [];
-     * const makeTask = (n: number) => Task.from.Promise(() => {
-     *   log.push(n);
-     *   return Promise.resolve(n);
-     * });
+     * const makeTask = (n: number) => Task.resolve(n);
      *
      * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
      * // log = [1, 2, 3] — tasks ran in order
@@ -2089,16 +2081,15 @@ declare namespace Validation {
         const failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
     }
     /**
-     * Creates a Validation from a function that may throw.
-     * Catches any errors and transforms them using the onError function into a Failed validation.
+     * Creates a Validation from a synchronous thunk that may throw.
+     * Catches any errors and transforms them using the `onError` function into a Failed validation.
      *
      * @example
      * ```ts
-     * const parseJson = (s: string): Validation<string, unknown> =>
-     *   Validation.tryCatch(
-     *     () => JSON.parse(s),
-     *     { onError: (e) => `Parse error: ${e}` }
-     *   );
+     * const result = Validation.tryCatch(
+     *   () => JSON.parse(rawString),
+     *   { onError: (e) => `Parse error: ${e}` }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: () => A, options: {

package/dist/{chunk-5OFVS5UZ.mjs → chunk-JSG7SFXS.js}

@@ -1,6 +1,6 @@
 import {
   Duration
-} from "./chunk-DENXUTKL.mjs";
+} from "./chunk-OIIOGDHK.js";
 
 // src/Composition/compose.ts
 function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {