Variable AsyncReadable

Type Declaration

• AsyncReadableTypeId: symbol

• fromReadable: {
      <A, B, E, R>(
          f: (a: A) => Effect<B, E, R>,
      ): (
          self: Readable.Readable<A>,
      ) => Effect<AsyncReadable<B, E>, never, Scope | R>;
      <A, B, E, R>(
          self: Readable.Readable<A>,
          f: (a: A) => Effect<B, E, R>,
      ): Effect<AsyncReadable<B, E>, never, Scope | R>;
  }

  Create an AsyncReadable that recomputes when a source Readable changes. Similar to a derived async value.

  Param: f

  Function that takes the current value and returns an Effect

  Example

  const userId = yield* Signal.make(1)
  const userData = yield* userId.pipe(
    AsyncReadable.fromReadable((id) =>
      Effect.gen(function* () {
        const response = yield* fetchUser(id)
        return response.data
      })
    )
  )
  Copy

• isAsyncReadable: (value: unknown) => value is AsyncReadable<unknown, unknown>

  Check if a value is an AsyncReadable.

• make: <A, E = never, R = never>(
      fetch: () => Effect<A, E, R>,
  ) => Effect<AsyncReadable<A, E>, never, Scope | R>

  Create an AsyncReadable from an Effect-returning fetch function. Returns the handle synchronously; the initial fetch runs in the background under the caller's scope.

  On construction the handle reads isLoading = true, value = None, error = None. When the fetch settles, isLoading flips to false and either value or error fills in. Consumers can subscribe to isLoading for a loading indicator or wrap the whole thing in Boundary.suspense when a blocking UX is wanted — the split between "observable loading" and "suspending" is deliberate.

  Example

  const userData = yield* AsyncReadable.make(() =>
    Effect.gen(function* () {
      const response = yield* fetchUser(userId)
      return response.data
    })
  )
  Copy

• map: {
      <A, B>(
          f: (a: A) => B,
      ): <E>(self: AsyncReadable<A, E>) => AsyncReadable<B, E>;
      <A, E, B>(self: AsyncReadable<A, E>, f: (a: A) => B): AsyncReadable<B, E>;
  }

  Map the successful value of an AsyncReadable.

  Param: f

  Function to transform the value

  Example

  const userData = yield* AsyncReadable.make(fetchUser)
  const userName = userData.pipe(AsyncReadable.map(user => user.name))
  Copy

• promise: <A>(fetch: () => Promise<A>) => Effect<AsyncReadable<A, never>, never, Scope>

  Create an AsyncReadable from a Promise-returning function.

  Example

  const userData = yield* AsyncReadable.promise(() =>
    fetch('/api/user').then(r => r.json())
  )
  Copy

• tryPromise: <A, E>(
      fetch: () => Promise<A>,
      onError: (error: unknown) => E,
  ) => Effect<AsyncReadable<A, E>, never, Scope>

  Create an AsyncReadable from a Promise-returning function with error handling.

  Example

  const userData = yield* AsyncReadable.tryPromise(
    () => fetch('/api/user').then(r => r.json()),
    (error) => new FetchError(error)
  )
  Copy