Getting Started #

import { Effect } from "effect"

// This builds a description. Nothing prints yet.
const sayHi = Effect.sync(() => console.log("hi"))

console.log("before running")

// Running the description does the work. Running twice does it twice.
Effect.runSync(sayHi)
Effect.runSync(sayHi)

console.log("after running")

import { Effect, Exit } from "effect"

const ok = Effect.succeed(42)              // Effect<number, never, never>
const bad = Effect.fail("no permission")   // Effect<never, string, never>

const exit1 = Effect.runSyncExit(ok)
const exit2 = Effect.runSyncExit(bad)

console.log(exit1._tag, Exit.isSuccess(exit1) ? exit1.value : "")
console.log(exit2._tag, Exit.isFailure(exit2) ? "it failed" : "")

import { Effect } from "effect"

// Two tiny "services" that just return data
const loadUser = (id: string) => Effect.succeed({ id, name: "Ada" })
const loadPosts = (userId: string) => Effect.succeed(["post-1", "post-2", "post-3"])

// Same shape as async/await, with yield* instead of await
const program = Effect.gen(function* () {
  const user = yield* loadUser("1")
  const posts = yield* loadPosts(user.id)
  console.log(user.name, "has", posts.length, "posts")
  return posts.length
})

const count = Effect.runSync(program)
console.log("returned:", count)

import { Effect } from "effect"

const getPrice = Effect.succeed(100)

const program = getPrice.pipe(
  Effect.map((price) => price * 1.15),                        // add tax
  Effect.tap((total) => Effect.sync(() => console.log("total is", total))),
  Effect.andThen((total) => Effect.succeed("charged " + total)) // chain into another Effect
)

console.log(Effect.runSync(program))

import { Effect, Option } from "effect"

const names: Record<number, string> = { 1: "Ada", 2: "Lin", 3: "Bo" }
const loadName = (id: number) => Effect.succeed(names[id] ?? "?")
const countPosts = (id: number) => Effect.succeed(id * 2)
const notify = (name: string) => Effect.sync(() => console.log("notified", name))
const isAdmin = (id: number) => Effect.succeed(id === 1)

const program = Effect.gen(function* () {
  // 1. forEach: one effect per element, in order. The results come back as an array.
  const loaded = yield* Effect.forEach([1, 2, 3], loadName)          // Array<string>
  console.log("names:", loaded.join(", "))

  // 2. forEach with discard: only the side effects. The result is void.
  yield* Effect.forEach(loaded, notify, { discard: true })

  // 3. all over a tuple: the result is a typed tuple.
  const [name, posts] = yield* Effect.all([loadName(1), countPosts(1)])   // [string, number]
  console.log(name, "has", posts, "posts")

  // 4. all over an object: the result has the same keys as the input.
  const data = yield* Effect.all({ name: loadName(2), posts: countPosts(2) })   // { name: string; posts: number }
  console.log(data.name, "has", data.posts, "posts")

  // 5. when: the effect runs only if the condition effect gives true. The result is an Option.
  const sent = yield* Effect.when(notify("admin Ada"), isAdmin(1))
  const skipped = yield* Effect.when(notify("admin Lin"), isAdmin(2))
  console.log("sent:", Option.isSome(sent), "skipped:", Option.isNone(skipped))
})

Effect.runSync(program)

import { Effect } from "effect"

// 1. A plain loop inside Effect.gen. yield* runs each step.
const countdown = Effect.gen(function* () {
  for (let n = 3; n > 0; n--) {
    yield* Effect.sync(() => console.log("t-minus", n))
  }
  console.log("liftoff")
})

// 2. whileLoop: while and body are functions, so both run at run time, not before.
let remaining = 3
const drain = Effect.whileLoop({
  while: () => remaining > 0,
  body: () => Effect.sync(() => remaining--),
  step: (left) => console.log("drained, before:", left)
})

// 3. Recursion without suspend. The call eagerSumTo(5) builds the whole chain before any run.
let built = 0
const eagerSumTo = (n: number): Effect.Effect<number> => {
  built++
  return n === 0 ? Effect.succeed(0) : Effect.map(eagerSumTo(n - 1), (rest) => rest + n)
}
const eager = eagerSumTo(5)
console.log("eager: built", built, "effects before run")

// 4. suspend delays the body until the effect runs. The call lazySumTo(5) builds nothing.
built = 0
const lazySumTo = (n: number): Effect.Effect<number> =>
  Effect.suspend(() => {
    built++
    return n === 0 ? Effect.succeed(0) : Effect.map(lazySumTo(n - 1), (rest) => rest + n)
  })
const lazy = lazySumTo(5)
console.log("lazy: built", built, "effects before run")

Effect.runSync(countdown)
Effect.runSync(drain)
console.log("eager sum:", Effect.runSync(eager))
console.log("lazy sum:", Effect.runSync(lazy), "- built", built, "during the run")

import { Effect } from "effect"

// A sync operation that can throw, made safe and typed
const parseJson = (raw: string) =>
  Effect.try({
    try: () => JSON.parse(raw) as { port: number },
    catch: () => "invalid json"          // Effect<{ port: number }, string>
  })

// A fake async API that rejects for unknown ids
const fakeFetch = (id: number): Promise<string> =>
  id === 1 ? Promise.resolve("Ada") : Promise.reject(new Error("404"))

const fetchName = (id: number) =>
  Effect.tryPromise({
    try: () => fakeFetch(id),
    catch: () => "user " + id + " not found"   // Effect<string, string>
  })

const program = Effect.gen(function* () {
  const config = yield* parseJson('{"port": 8080}')
  const name = yield* fetchName(1)
  console.log("port", config.port, "user", name)
})

Effect.runPromise(program)

import { Effect, Exit } from "effect"

const syncWork = Effect.succeed("sync result")
const asyncWork = Effect.promise(() => new Promise<string>((resolve) => setTimeout(() => resolve("async result"), 10)))
const failing = Effect.fail("boom")

const main = async () => {
  console.log(Effect.runSync(syncWork))
  console.log(await Effect.runPromise(asyncWork))

  const exit = await Effect.runPromiseExit(failing)
  console.log(Exit.isFailure(exit) ? "handled failure without throwing" : "unexpected")

  try {
    Effect.runSync(asyncWork)   // async inside runSync is not allowed
  } catch (e) {
    console.log("runSync refused async work")
  }
}

main()

import { Effect } from "effect"

const program = Effect.gen(function* () {
  const n = Effect.succeed(1)
  console.log(n + 1)
})

Effect.runSync(program)

import { Effect } from "effect"

const program = Effect.sync(() => console.log("hello from effect"))

program

import { Effect } from "effect"

const greet = (name: string) => Effect.sync(() => console.log("hello", name))

const program = Effect.gen(function* () {
  for (const name of ["Ada", "Lin"]) {
    greet(name)
  }
  console.log("done")
})

Effect.runSync(program)

import { Effect } from "effect"

const loadName = (id: number) => Effect.succeed(id === 1 ? "Ada" : "Lin")
const countPosts = (id: number) => Effect.succeed(id * 2)

const program = Effect.gen(function* () {
  const data = yield* Effect.all({ name: loadName(1), posts: countPosts(1) })
  console.log(data.name, "has", data.postCount, "posts")
})

Effect.runSync(program)

import { Cause, Effect, Exit } from "effect"

const parse = (raw: string) =>
  Effect.sync(() => JSON.parse(raw) as { name: string })

const exit = Effect.runSyncExit(parse("{ not json"))

if (Exit.isFailure(exit)) {
  console.log("error:", Cause.squash(exit.cause))
} else {
  console.log("parsed", exit.value.name)
}

import { Effect } from "effect"

const wait = Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, 5)))

const program = Effect.gen(function* () {
  yield* wait
  console.log("done after 5ms")
})

Effect.runSync(program)

import { Effect } from "effect"

const double = (n: number) => Effect.succeed(n * 2)

const program = Effect.succeed(10).pipe(
  Effect.map((n) => double(n)),
  Effect.map((result) => console.log(String(result)))
)

Effect.runSync(program)

import { Effect, Exit } from "effect"

const parseAge = (input: string): Effect.Effect<number> => {
  const n = Number(input)
  return Number.isNaN(n) ? Effect.fail("not a number: " + input) : Effect.succeed(n)
}

for (const input of ["30", "abc"]) {
  const exit = Effect.runSyncExit(parseAge(input))
  console.log(Exit.isSuccess(exit) ? "age " + exit.value : "rejected " + input)
}