Data Types #

import { Option } from "effect"

interface User {
  readonly id: number
  readonly name: string
  readonly email?: string
}

const users: ReadonlyArray<User> = [
  { id: 1, name: "Ada", email: "ada@example.com" },
  { id: 2, name: "Lin" }
]

// Array.find returns User | undefined. fromNullishOr turns that into Option<User>.
const findUser = (id: number): Option.Option<User> =>
  Option.fromNullishOr(users.find((u) => u.id === id))

// Every step is total: it has an answer for Some and for None, no if-checks in between
const emailDomain = (id: number): string =>
  findUser(id).pipe(
    Option.flatMap((u) => Option.fromNullishOr(u.email)),   // email is optional too
    Option.map((email) => email.split("@")[1]),
    Option.getOrElse(() => "no email")
  )

console.log(emailDomain(1))
console.log(emailDomain(2))
console.log(emailDomain(3))

// match when the two branches need different code
const describe = findUser(2).pipe(
  Option.match({
    onNone: () => "unknown user",
    onSome: (u) => "user " + u.name
  })
)
console.log(describe)

import { Effect, Option } from "effect"

const prices = new Map([["apple", 120], ["pear", 95]])

// Map.get returns number | undefined, so this is Option<number>
const price = (item: string): Option.Option<number> => Option.fromNullishOr(prices.get(item))

// Effect.fromOption: Some -> success, None -> fails with NoSuchElementError
const total = (items: ReadonlyArray<string>) =>
  Effect.gen(function* () {
    let sum = 0
    for (const item of items) {
      sum += yield* Effect.fromOption(price(item))   // Effect<number, NoSuchElementError>
    }
    return sum
  })

const program = Effect.gen(function* () {
  console.log("total:", yield* total(["apple", "pear"]))

  // Effect.option goes the other way: the failure becomes a None, no error channel left
  const maybe = yield* Effect.option(total(["apple", "kiwi"]))
  console.log("with kiwi:", String(maybe))

  // Give None a custom error instead of NoSuchElementError. flip swaps error and success so we can print it.
  const err = yield* Effect.flip(Effect.fromOption(price("kiwi"), () => "kiwi is not for sale"))
  console.log(err)
})

Effect.runSync(program)

import { Effect, Result } from "effect"

// A pure validation. It returns a Result instead of throwing.
const parseAge = (raw: string): Result.Result<number, string> => {
  const n = Number(raw)
  if (Number.isNaN(n)) return Result.fail("not a number: " + raw)
  if (n < 0 || n > 150) return Result.fail("out of range: " + n)
  return Result.succeed(n)
}

// Results are values: transform and fold them without running anything
for (const raw of ["42", "abc", "200"]) {
  const message = parseAge(raw).pipe(
    Result.map((age) => age + 1),                 // only touches a Success
    Result.mapError((e) => e.toUpperCase()),      // only touches a Failure
    Result.match({
      onFailure: (e) => "rejected (" + e + ")",
      onSuccess: (age) => "next year " + age
    })
  )
  console.log(message)
}

const program = Effect.gen(function* () {
  // fromResult: the string failure moves into the Effect error channel
  const age = yield* Effect.fromResult(parseAge("30"))
  console.log("age from effect:", age)

  // Effect.result: capture the outcome as a value instead of failing
  const captured = yield* Effect.result(Effect.fromResult(parseAge("x")))
  console.log("captured:", String(captured))
})

Effect.runSync(program)

import { Duration, Effect } from "effect"

// Three ways to say the same thing
const a = Duration.seconds(5)
const b = Duration.millis(5000)
const c = Duration.fromInputUnsafe("5 seconds")   // the string form every Effect API accepts

console.log(Duration.equals(a, b), Duration.equals(b, c))
console.log(Duration.toMillis(Duration.fromInputUnsafe("1.5 minutes")))
console.log(Duration.format(Duration.sum(Duration.minutes(1), Duration.millis(2500))))
console.log(Duration.isLessThan(Duration.millis(900), Duration.seconds(1)))

// sleep and timeout take a Duration.Input: a Duration, a string, or a number of millis
const slowJob = Effect.sleep("50 millis").pipe(Effect.as("job done"))

const main = async () => {
  // Plenty of time: the job finishes
  console.log(await Effect.runPromise(Effect.timeout(slowJob, "1 second")))

  // Not enough time: a typed TimeoutError. flip swaps it into the success channel so we can print it.
  const err = await Effect.runPromise(Effect.flip(Effect.timeout(slowJob, "10 millis")))
  console.log(err._tag)
}

main()

import { DateTime, Duration, Option } from "effect"

// Build from a fixed ISO string. In real code: yield* DateTime.now inside an Effect.
const launch = DateTime.makeUnsafe("2024-06-15T14:30:00Z")

console.log(DateTime.formatIso(launch))
console.log(DateTime.formatIso(DateTime.add(launch, { days: 20 })))          // calendar math
console.log(DateTime.formatIso(DateTime.addDuration(launch, "90 minutes")))  // duration math
console.log(DateTime.formatIso(DateTime.startOf(launch, "month")))
console.log(DateTime.formatIso(launch))   // the original never changed

// Parsing user input: make returns an Option instead of an Invalid Date
console.log(String(DateTime.make("not a date")))
console.log(DateTime.make("2024-12-25").pipe(Option.map(DateTime.formatIsoDate), Option.getOrElse(() => "invalid")))

// The gap between two instants is a Duration
const deadline = DateTime.makeUnsafe("2024-06-18T09:00:00Z")
console.log(Duration.format(DateTime.distance(launch, deadline)))

// Time zones: the instant stays the same, the calendar view changes
const tokyo = DateTime.setZoneNamedUnsafe(launch, "Asia/Tokyo")
console.log(DateTime.formatIsoZoned(tokyo))
console.log(DateTime.toParts(tokyo).hour, DateTime.toPartsUtc(tokyo).hour)

import { Data, Equal } from "effect"

// Data.Class: readonly fields, constructed from one object
class Point extends Data.Class<{ readonly x: number; readonly y: number }> {}

const p1 = new Point({ x: 1, y: 2 })
const p2 = new Point({ x: 1, y: 2 })
console.log(p1 === p2, Equal.equals(p1, p2))   // reference vs value equality

// Data.TaggedClass adds a _tag you did not have to write
class Money extends Data.TaggedClass("Money")<{ readonly cents: number; readonly currency: string }> {}

const m = new Money({ cents: 500, currency: "EUR" })
console.log(m._tag, m.cents, Equal.equals(m, new Money({ cents: 500, currency: "EUR" })))

// Data.taggedEnum: a whole union with constructors and an exhaustive matcher
type Shape = Data.TaggedEnum<{
  Circle: { readonly radius: number }
  Rect: { readonly w: number; readonly h: number }
}>
const { Circle, Rect, $match } = Data.taggedEnum<Shape>()

const area = $match({
  Circle: ({ radius }) => Math.round(Math.PI * radius * radius),
  Rect: ({ w, h }) => w * h
})

console.log(area(Circle({ radius: 2 })), area(Rect({ w: 3, h: 4 })))
console.log(Equal.equals(Circle({ radius: 2 }), Circle({ radius: 2 })))

import { Chunk, Equal, HashMap, HashSet, Option } from "effect"

// Chunk: immutable, cheap append, value equality
const c1 = Chunk.make(1, 2, 3)
const c2 = Chunk.append(c1, 4)          // c1 is untouched
console.log(Chunk.toArray(c1).join(","), Chunk.toArray(c2).join(","))
console.log(Equal.equals(Chunk.make(1, 2), Chunk.make(1, 2)), Chunk.make(1, 2) === Chunk.make(1, 2))

// HashMap with a structural key: a fresh object with the same fields finds the entry
const stock = HashMap.make(
  [{ warehouse: "A", sku: "bolt" }, 120],
  [{ warehouse: "B", sku: "bolt" }, 8]
)
console.log(String(HashMap.get(stock, { warehouse: "B", sku: "bolt" })))
console.log(String(HashMap.get(stock, { warehouse: "C", sku: "bolt" })))

// set returns a new map; the old one is unchanged
const restocked = HashMap.set(stock, { warehouse: "B", sku: "bolt" }, 50)
const count = (map: HashMap.HashMap<{ warehouse: string; sku: string }, number>) =>
  HashMap.get(map, { warehouse: "B", sku: "bolt" }).pipe(Option.getOrElse(() => 0))
console.log(count(stock), count(restocked))

// HashSet dedupes by value, JS Set by reference
const tags = HashSet.fromIterable([{ id: 1 }, { id: 1 }, { id: 2 }])
console.log(HashSet.size(tags), new Set([{ id: 1 }, { id: 1 }, { id: 2 }]).size)

import { Config, ConfigProvider, Effect, Equal, Redacted } from "effect"

// Plain TypeScript: a string prints everywhere, so the secret is now in the log
const plainToken = "sk-live-12345"
console.log("plain: request failed for token " + plainToken)

// Redacted: the same value, but each print form shows <redacted>
const token = Redacted.make("sk-live-12345")
console.log("log:", token)
console.log("concat: request failed for token " + token)
console.log("json:", JSON.stringify({ token }))

// The value is still there. Ask for it at the point of use, and nowhere else.
const header = "Bearer " + Redacted.value(token)
console.log("header length:", header.length)

// Compare 2 secrets by value. No secret becomes text.
console.log("equal:", Equal.equals(token, Redacted.make("sk-live-12345")))
console.log("equal:", Equal.equals(token, Redacted.make("sk-test-00000")))

// A label says which secret it is, not what it is
console.log("labelled:", String(Redacted.make("hunter2", { label: "DB_PASSWORD" })))

// Config.redacted reads a key as Redacted<string>, so a log of the config cannot show it
const program = Effect.gen(function* () {
  const apiKey = yield* Config.redacted("API_KEY")
  console.log("config:", apiKey)
  return Redacted.value(apiKey).length
})

const TestConfig = ConfigProvider.layer(ConfigProvider.fromUnknown({ API_KEY: "sk-live-12345" }))
console.log("key length:", Effect.runSync(Effect.provide(program, TestConfig)))

import { BigDecimal, Equal } from "effect"

// Plain numbers are binary floats. They cannot store 0.1 exactly.
console.log(0.1 + 0.2, 0.1 + 0.2 === 0.3)

// BigDecimal stores a bigint and a scale: 0.1 is 1n with scale 1. The sum is exact.
const a = BigDecimal.fromStringUnsafe("0.1")
const b = BigDecimal.fromStringUnsafe("0.2")
const sum = BigDecimal.sum(a, b)
console.log(BigDecimal.format(sum), BigDecimal.equals(sum, BigDecimal.fromStringUnsafe("0.3")))

// 3 constructors for the same value. fromString returns an Option for text that you do not trust.
console.log(BigDecimal.equals(BigDecimal.make(1999n, 2), BigDecimal.fromStringUnsafe("19.99")), BigDecimal.format(BigDecimal.fromNumberUnsafe(19.99)))
console.log(String(BigDecimal.fromString("19.99x")))

// round uses "half-from-zero" by default. scale cuts the extra digits. format removes zeros at the end.
const raw = BigDecimal.fromStringUnsafe("11.3943")
console.log(BigDecimal.format(BigDecimal.round(raw, { scale: 2 })), BigDecimal.format(BigDecimal.scale(raw, 1)), BigDecimal.format(BigDecimal.fromStringUnsafe("5.00")))

// === compares references. equals, Equal.equals and Order compare the value.
console.log(a === BigDecimal.fromStringUnsafe("0.1"), Equal.equals(a, BigDecimal.fromStringUnsafe("0.1")))
console.log(BigDecimal.isLessThan(a, b), [b, a].sort(BigDecimal.Order).map(BigDecimal.format).join(" "))

// A small invoice: 2 lines, 19% VAT rounded to cents
const lines = [["19.99", 3n], ["4.25", 2n]] as const
const net = BigDecimal.sumAll(
  lines.map(([price, qty]) => BigDecimal.multiply(BigDecimal.fromStringUnsafe(price), BigDecimal.fromBigInt(qty)))
)
const vat = BigDecimal.round(BigDecimal.multiply(net, BigDecimal.fromStringUnsafe("0.19")), { scale: 2 })
console.log("net", BigDecimal.format(net), "vat", BigDecimal.format(vat), "total", BigDecimal.format(BigDecimal.sum(net, vat)))

import { Option } from "effect"

const config: { port?: number } = {}

const port = Option.fromNullable(config.port).pipe(
  Option.getOrElse(() => 8080)
)

console.log("port", port)

import { Option } from "effect"

const nicknames = new Map([["ada", "The Countess"]])

const greet = (user: string) =>
  Option.fromNullishOr(nicknames.get(user)).pipe(
    Option.getOrElse("stranger")
  )

console.log(greet("ada"))

import { Option } from "effect"

const safeSqrt = (n: number): Option.Option<number> =>
  n >= 0 ? Option.some(Math.sqrt(n)) : Option.none()

const parse = (s: string): Option.Option<number> => {
  const n = Number(s)
  return Number.isNaN(n) ? Option.none() : Option.some(n)
}

const run = (input: string) =>
  parse(input).pipe(
    Option.map((n) => safeSqrt(n)),
    Option.getOrElse(() => -1)
  )

for (const s of ["16", "-4", "abc"]) {
  console.log(String(run(s)))
}

import { Effect, Option } from "effect"

const names = new Map([[1, "Ada"], [2, "Lin"]])

// Callers rely on this never failing: unknown ids must become "guest"
const displayName = (id: number): Effect.Effect<string> =>
  Effect.gen(function* () {
    const name = yield* Effect.fromOption(Option.fromNullishOr(names.get(id)))
    return name.toUpperCase()
  })

const program = Effect.gen(function* () {
  console.log(yield* displayName(1))
  console.log(yield* displayName(3))
})

Effect.runSync(program)

import { Effect } from "effect"

// Simulates a call that takes about 30ms
const fetchReport = Effect.sleep("30 millis").pipe(Effect.as("report ready"))

// Intended: give up after 2 seconds
const program = fetchReport.pipe(
  Effect.timeout(2),
  Effect.catchTag("TimeoutError", () => Effect.succeed("gave up"))
)

Effect.runPromise(program).then(console.log)

import { DateTime } from "effect"

const signup = DateTime.makeUnsafe("2024-02-29T10:00:00Z")

// Trial lasts 30 days
let trialEnds = signup
DateTime.add(trialEnds, { days: 30 })

console.log("trial ends", DateTime.formatIsoDate(trialEnds))

import { Redacted } from "effect"

const apiKey = Redacted.make("sk-live-12345")

// Builds the header of an outgoing request. It needs the text of the key.
const authHeader = (key: string): string => "Bearer " + key

const header = authHeader(apiKey)
console.log("header length:", header.length)

import { BigDecimal } from "effect"

const paid = BigDecimal.fromStringUnsafe("100.00")
const due = BigDecimal.sum(BigDecimal.fromStringUnsafe("59.97"), BigDecimal.fromStringUnsafe("40.03"))

// Is the invoice settled?
if (paid === due) {
  console.log("settled")
} else {
  console.log("open: " + BigDecimal.format(BigDecimal.subtract(due, paid)))
}