tim-smart

Effect Atom + React: data fetching (Effect v4)

Examples for Effect v4 RC with the Atom modules that now live in core Effect, plus React bindings from @effect/atom-react.

Verified against effect@4.0.0-rc.109 / @effect/atom-react@4.0.0-rc.109.

Install

tim-smart

import { Cause, Effect, Schema } from "effect"
import { Model } from "effect/unstable/schema"
import { SqlClient, SqlModel } from "effect/unstable/sql"
import type { SqlError } from "effect/unstable/sql/SqlError"

const UserId = Schema.String.pipe(
  Schema.brand("UserId")
)
type UserId = typeof UserId.Type

tim-smart

import { NodeRuntime, NodeServices } from "@effect/platform-node"
import { Console, Effect, Stream } from "effect"
import { ChildProcess } from "effect/unstable/process"
import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"

Effect.gen(function*() {
  const spawner = yield* ChildProcessSpawner
  const handle = yield* spawner.spawn(ChildProcess.make`git diff`)
  yield* handle.stdout.pipe(
    Stream.decodeText,

tim-smart

import { Effect, PubSub, Schema } from "effect"
import { ClusterSchema, Entity, EntityResource, SingleRunner } from "effect/unstable/cluster"
import { Rpc } from "effect/unstable/rpc"

const Counter = Entity.make("Counter", [
  Rpc.make("increment", {
    payload: {
      amount: Schema.Number
    }
  }).annotate(ClusterSchema.Persisted, true)

tim-smart

/**
 * @since 1.0.0
 */
import { Config, Context, Data, Effect, Layer } from "effect"
import * as Api from "playwright"

export class PlaywrightError extends Data.TaggedError("PlaywrightError")<{
  readonly cause: unknown
}> {}

tim-smart

import type { Chunk, Scope } from "effect"
import { Channel, Data, Effect, Mailbox } from "effect"
import type { AsyncInputProducer } from "effect/SingleProducerAsyncInput"

class WebSocketError extends Data.TaggedError("WebSocketError")<{
  cause: unknown
}> {}

const makeChannelDuplex = <Out, In, Err, R = never>(
  f: (mailbox: Mailbox.Mailbox<Out, Err>) => Effect.Effect<(item: In) => Effect.Effect<void>, Err, R | Scope.Scope>

tim-smart

import { Equal, Hash } from "effect"
import * as Context from "effect/Context"
import * as Data from "effect/Data"
import * as Deferred from "effect/Deferred"
import * as Effect from "effect/Effect"
import * as Exit from "effect/Exit"
import * as MutableHashMap from "effect/MutableHashMap"
import * as MutableRef from "effect/MutableRef"
import * as Option from "effect/Option"
import * as Scope from "effect/Scope"

tim-smart

import type { StandardSchemaV1 } from "@standard-schema/spec"
import { NonEmptyArray } from "effect/Array"
import * as Data from "effect/Data"
import * as Effect from "effect/Effect"
import * as Predicate from "effect/Predicate"

export class StandardSchemaError extends Data.TaggedError(
  "StandardSchemaError",
)<{ readonly issues: NonEmptyArray<StandardSchemaV1.Issue> }> {
  static fromFailure(

tim-smart

import {
  Data,
  Effect,
  Layer,
  pipe,
  PubSub,
  Schedule,
  Scope,
  Stream,
} from "effect"

tim-smart

import * as Fs from "node:fs/promises"

export async function* readLinesReverse(path: string, chunkSize = 1024) {
  const file = await Fs.open(path, "r")
  const stat = await file.stat()

  let pos = stat.size
  let buffer: Buffer | null = null
  while (true) {
    pos = Math.max(0, pos - chunkSize)