effect-gpt 0.1.0

package/src/model/SelfAttention.ts

@@ -0,0 +1,169 @@
+import * as Effect from "effect/Effect"
+import * as FiberId from "effect/FiberId"
+import type { Tensor2D } from "../tensor/Tensor2D"
+import * as T from "../tensor/Tensor2D"
+import * as Ops from "../tensor/ops"
+import type { ShapeError } from "../tensor/ops"
+import type { ModelLayer } from "./ModelLayer"
+import { EMBEDDING_DIM } from "../config"
+import { Adam } from "../training/Adam"
+import type { Rng } from "../tensor/random"
+
+export class SelfAttention implements ModelLayer {
+  readonly _tag = "SelfAttention"
+  readonly embeddingDim: number
+  wQ: Tensor2D
+  wK: Tensor2D
+  wV: Tensor2D
+
+  private cache = new Map<number | string, Tensor2D>()
+  private lastCache: Tensor2D | null = null
+  optimizerWQ: Adam
+  optimizerWK: Adam
+  optimizerWV: Adam
+
+  constructor(embeddingDim: number = EMBEDDING_DIM, rng: Rng) {
+    this.embeddingDim = embeddingDim
+    const std = Math.sqrt(2.0 / embeddingDim)
+    this.wQ = Ops.initNormal(embeddingDim, embeddingDim, 0, std, rng)
+    this.wK = Ops.initNormal(embeddingDim, embeddingDim, 0, std, rng)
+    this.wV = Ops.initNormal(embeddingDim, embeddingDim, 0, std, rng)
+    this.optimizerWQ = Adam.make(embeddingDim, embeddingDim)
+    this.optimizerWK = Adam.make(embeddingDim, embeddingDim)
+    this.optimizerWV = Adam.make(embeddingDim, embeddingDim)
+  }
+
+  private fiberKey(fiberId: FiberId.FiberId): number | string {
+    return FiberId.isRuntime(fiberId) ? fiberId.id : JSON.stringify(fiberId)
+  }
+
+  get parametersCount(): number {
+    return this.wQ.data.length + this.wK.data.length + this.wV.data.length
+  }
+
+  private computeQKV(input: Tensor2D): Effect.Effect<{ q: Tensor2D; k: Tensor2D; v: Tensor2D }, ShapeError> {
+    return Effect.gen(this, function* () {
+      const q: Tensor2D = yield* Ops.matMul(input, this.wQ)
+      const k: Tensor2D = yield* Ops.matMul(input, this.wK)
+      const v: Tensor2D = yield* Ops.matMul(input, this.wV)
+      return { q, k, v }
+    })
+  }
+
+  private attention(q: Tensor2D, k: Tensor2D, v: Tensor2D): Effect.Effect<Tensor2D, ShapeError> {
+    return Effect.gen(this, function* () {
+      const dk = Math.sqrt(this.embeddingDim)
+      const kT = Ops.transpose(k)
+      const scores = yield* Ops.matMul(q, kT)
+      const scaledScores = Ops.mulScalar(scores, 1 / dk)
+
+      const seqLen = scaledScores.rows
+      for (let i = 0; i < seqLen; i++) {
+        for (let j = i + 1; j < seqLen; j++) {
+          T.set(scaledScores, i, j, -Infinity)
+        }
+      }
+
+      const weights = Ops.softmaxRows(scaledScores)
+      const attended = yield* Ops.matMul(weights, v)
+      return attended
+    })
+  }
+
+  forward(input: Tensor2D): Effect.Effect<Tensor2D, ShapeError> {
+    return Effect.gen(this, function* () {
+      const fiberId = yield* Effect.fiberId
+      const key = this.fiberKey(fiberId)
+      const cloned = T.clone(input)
+      this.cache.set(key, cloned)
+      this.lastCache = cloned
+      const { q, k, v } = yield* this.computeQKV(input)
+      const attended = yield* this.attention(q, k, v)
+      const output = yield* Ops.add(attended, input)
+      return output
+    })
+  }
+
+  private static softmaxBackward(softmaxOutput: Tensor2D, gradOutput: Tensor2D): Tensor2D {
+    const gradInput = T.zeros(softmaxOutput.rows, softmaxOutput.cols)
+    for (let i = 0; i < softmaxOutput.rows; i++) {
+      let dot = 0
+      const rowOffset = i * softmaxOutput.cols
+      for (let j = 0; j < softmaxOutput.cols; j++) {
+        dot += softmaxOutput.data[rowOffset + j] * gradOutput.data[rowOffset + j]
+      }
+      for (let j = 0; j < softmaxOutput.cols; j++) {
+        const y = softmaxOutput.data[rowOffset + j]
+        const dy = gradOutput.data[rowOffset + j]
+        gradInput.data[rowOffset + j] = y * (dy - dot)
+      }
+    }
+    return gradInput
+  }
+
+  backward(dOut: Tensor2D, lr: number): Effect.Effect<Tensor2D, ShapeError> {
+    return Effect.gen(this, function* () {
+      const fiberId = yield* Effect.fiberId
+      const key = this.fiberKey(fiberId)
+      const cachedInput = this.cache.get(key) ?? this.lastCache
+      if (!cachedInput) {
+        return yield* Effect.fail(new Ops.ShapeError("SelfAttention.backward called before forward"))
+      }
+      this.cache.delete(key)
+      this.lastCache = null
+
+      const input = cachedInput
+      const q = yield* Ops.matMul(input, this.wQ)
+      const k = yield* Ops.matMul(input, this.wK)
+      const v = yield* Ops.matMul(input, this.wV)
+      const scale = Math.sqrt(this.wQ.cols)
+
+      const kT = Ops.transpose(k)
+      const scores = yield* Ops.matMul(q, kT)
+      const scaledScores = Ops.mulScalar(scores, 1 / scale)
+
+      const seqLen = scaledScores.rows
+      for (let i = 0; i < seqLen; i++) {
+        for (let j = i + 1; j < seqLen; j++) {
+          T.set(scaledScores, i, j, -Infinity)
+        }
+      }
+
+      const attnWeights = Ops.softmaxRows(scaledScores)
+
+      const vT = Ops.transpose(v)
+      const gradAttnWeights = yield* Ops.matMul(dOut, vT)
+      const attnWeightsT = Ops.transpose(attnWeights)
+      const gradV = yield* Ops.matMul(attnWeightsT, dOut)
+
+      const gradScores = SelfAttention.softmaxBackward(attnWeights, gradAttnWeights)
+      const gradScoresScaled = Ops.mulScalar(gradScores, 1 / scale)
+
+      const gradQ = yield* Ops.matMul(gradScoresScaled, k)
+      const gradScoresScaledT = Ops.transpose(gradScoresScaled)
+      const gradK = yield* Ops.matMul(gradScoresScaledT, q)
+
+      const inputT = Ops.transpose(input)
+      const gradWQ = yield* Ops.matMul(inputT, gradQ)
+      const gradWK = yield* Ops.matMul(inputT, gradK)
+      const gradWV = yield* Ops.matMul(inputT, gradV)
+
+      const wQT = Ops.transpose(this.wQ)
+      const wKT = Ops.transpose(this.wK)
+      const wVT = Ops.transpose(this.wV)
+      const gradInputQ = yield* Ops.matMul(gradQ, wQT)
+      const gradInputK = yield* Ops.matMul(gradK, wKT)
+      const gradInputV = yield* Ops.matMul(gradV, wVT)
+
+      const gradInputAttention = yield* Ops.add(gradInputQ, gradInputK)
+      const gradInputAttention2 = yield* Ops.add(gradInputAttention, gradInputV)
+      const gradInput = yield* Ops.add(gradInputAttention2, dOut)
+
+      this.optimizerWQ.step(this.wQ, gradWQ, lr)
+      this.optimizerWK.step(this.wK, gradWK, lr)
+      this.optimizerWV.step(this.wV, gradWV, lr)
+
+      return gradInput
+    })
+  }
+}

package/src/model/TransformerBlock.ts

@@ -0,0 +1,53 @@
+import * as Effect from "effect/Effect"
+import type { Tensor2D } from "../tensor/Tensor2D"
+import type { ShapeError } from "../tensor/ops"
+import type { ModelLayer } from "./ModelLayer"
+import { SelfAttention } from "./SelfAttention"
+import { FeedForward } from "./FeedForward"
+import { LayerNorm } from "./LayerNorm"
+import { EMBEDDING_DIM, HIDDEN_DIM } from "../config"
+import type { Rng } from "../tensor/random"
+
+export class TransformerBlock implements ModelLayer {
+  readonly _tag = "TransformerBlock"
+  attention: SelfAttention
+  feedForward: FeedForward
+  norm1: LayerNorm
+  norm2: LayerNorm
+
+  constructor(embeddingDim: number = EMBEDDING_DIM, hiddenDim: number = HIDDEN_DIM, rng: Rng) {
+    this.attention = new SelfAttention(embeddingDim, rng)
+    this.feedForward = new FeedForward(embeddingDim, hiddenDim, rng)
+    this.norm1 = new LayerNorm(embeddingDim)
+    this.norm2 = new LayerNorm(embeddingDim)
+  }
+
+  get parametersCount(): number {
+    return (
+      this.attention.parametersCount +
+      this.feedForward.parametersCount +
+      this.norm1.parametersCount +
+      this.norm2.parametersCount
+    )
+  }
+
+  forward(input: Tensor2D): Effect.Effect<Tensor2D, ShapeError> {
+    return Effect.gen(this, function* () {
+      const attentionOut: Tensor2D = yield* this.attention.forward(input)
+      const norm1Out: Tensor2D = yield* this.norm1.forward(attentionOut)
+      const ffnOut: Tensor2D = yield* this.feedForward.forward(norm1Out)
+      const norm2Out: Tensor2D = yield* this.norm2.forward(ffnOut)
+      return norm2Out
+    })
+  }
+
+  backward(dOut: Tensor2D, lr: number): Effect.Effect<Tensor2D, ShapeError> {
+    return Effect.gen(this, function* () {
+      let grad: Tensor2D = yield* this.norm2.backward(dOut, lr)
+      grad = yield* this.feedForward.backward(grad, lr)
+      grad = yield* this.norm1.backward(grad, lr)
+      grad = yield* this.attention.backward(grad, lr)
+      return grad
+    })
+  }
+}

package/src/services/Logger.ts

@@ -0,0 +1,124 @@
+import * as Effect from "effect/Effect"
+import * as Context from "effect/Context"
+import * as Layer from "effect/Layer"
+import { Terminal } from "@effect/platform"
+
+export type LogLevel = "debug" | "info" | "warn" | "error"
+
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+}
+
+export interface LoggerService {
+  readonly log: (level: LogLevel, message: string, data?: Record<string, unknown>) => Effect.Effect<void>
+  readonly debug: (message: string, data?: Record<string, unknown>) => Effect.Effect<void>
+  readonly info: (message: string, data?: Record<string, unknown>) => Effect.Effect<void>
+  readonly warn: (message: string, data?: Record<string, unknown>) => Effect.Effect<void>
+  readonly error: (message: string, data?: Record<string, unknown>) => Effect.Effect<void>
+}
+
+export interface LoggerServiceId {
+  readonly LoggerService: unique symbol
+}
+
+export const Logger = Context.GenericTag<LoggerServiceId, LoggerService>("LoggerService")
+
+type Formatter = (level: LogLevel, message: string, data?: Record<string, unknown>) => string
+
+const formatStructured: Formatter = (level, message, data) => {
+  const timestamp = new Date().toISOString()
+  const dataStr = data ? ` ${JSON.stringify(data)}` : ""
+  return `[${timestamp}] [${level.toUpperCase()}] ${message}${dataStr}\n`
+}
+
+const formatPretty: Formatter = (level, message, data) => {
+  const prefix: Record<LogLevel, string> = { debug: "🔍", info: "ℹ️ ", warn: "⚠️ ", error: "❌" }
+  const dataStr = data ? ` ${JSON.stringify(data)}` : ""
+  return `${prefix[level]} ${message}${dataStr}\n`
+}
+
+const makeLogger = (
+  minLevel: LogLevel,
+  write: (msg: string) => Effect.Effect<void>,
+  format: Formatter = formatStructured
+): LoggerService => ({
+  log: (level, message, data) =>
+    LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[minLevel]
+      ? write(format(level, message, data))
+      : Effect.void,
+  debug: (message, data) =>
+    LOG_LEVEL_PRIORITY.debug >= LOG_LEVEL_PRIORITY[minLevel]
+      ? write(format("debug", message, data))
+      : Effect.void,
+  info: (message, data) =>
+    LOG_LEVEL_PRIORITY.info >= LOG_LEVEL_PRIORITY[minLevel]
+      ? write(format("info", message, data))
+      : Effect.void,
+  warn: (message, data) =>
+    LOG_LEVEL_PRIORITY.warn >= LOG_LEVEL_PRIORITY[minLevel]
+      ? write(format("warn", message, data))
+      : Effect.void,
+  error: (message, data) =>
+    LOG_LEVEL_PRIORITY.error >= LOG_LEVEL_PRIORITY[minLevel]
+      ? write(format("error", message, data))
+      : Effect.void
+})
+
+export const ConsoleLoggerLive = (minLevel: LogLevel = "info"): Layer.Layer<LoggerServiceId> =>
+  Layer.succeed(
+    Logger,
+    makeLogger(minLevel, (msg) => Effect.sync(() => process.stdout.write(msg)))
+  )
+
+export const TerminalLoggerLive = (
+  minLevel: LogLevel = "info"
+): Layer.Layer<LoggerServiceId, never, Terminal.Terminal> =>
+  Layer.effect(
+    Logger,
+    Effect.gen(function* () {
+      const terminal = yield* Terminal.Terminal
+      return makeLogger(minLevel, (msg) =>
+        terminal.display(msg).pipe(
+          Effect.catchAll(() => Effect.void),
+          Effect.asVoid
+        )
+      )
+    })
+  )
+
+export const NullLoggerLive: Layer.Layer<LoggerServiceId> = Layer.succeed(
+  Logger,
+  makeLogger("error", () => Effect.void)
+)
+
+export const SilentLoggerLive: Layer.Layer<LoggerServiceId> = Layer.succeed(Logger, {
+  log: () => Effect.void,
+  debug: () => Effect.void,
+  info: () => Effect.void,
+  warn: () => Effect.void,
+  error: () => Effect.void
+})
+
+export const PrettyLoggerLive = (minLevel: LogLevel = "info"): Layer.Layer<LoggerServiceId> =>
+  Layer.succeed(
+    Logger,
+    makeLogger(minLevel, (msg) => Effect.sync(() => process.stdout.write(msg)), formatPretty)
+  )
+
+export const log = (level: LogLevel, message: string, data?: Record<string, unknown>) =>
+  Effect.flatMap(Logger, (logger) => logger.log(level, message, data))
+
+export const debug = (message: string, data?: Record<string, unknown>) =>
+  Effect.flatMap(Logger, (logger) => logger.debug(message, data))
+
+export const info = (message: string, data?: Record<string, unknown>) =>
+  Effect.flatMap(Logger, (logger) => logger.info(message, data))
+
+export const warn = (message: string, data?: Record<string, unknown>) =>
+  Effect.flatMap(Logger, (logger) => logger.warn(message, data))
+
+export const error = (message: string, data?: Record<string, unknown>) =>
+  Effect.flatMap(Logger, (logger) => logger.error(message, data))

package/src/services/Metrics.ts

@@ -0,0 +1,260 @@
+import * as Effect from "effect/Effect"
+import * as Context from "effect/Context"
+import * as Layer from "effect/Layer"
+import * as Clock from "effect/Clock"
+import * as Ref from "effect/Ref"
+import * as HashMap from "effect/HashMap"
+
+export interface Counter {
+  readonly inc: (n?: number) => Effect.Effect<void>
+  readonly get: () => Effect.Effect<number>
+}
+
+export interface Gauge {
+  readonly set: (value: number) => Effect.Effect<void>
+  readonly get: () => Effect.Effect<number>
+}
+
+export interface Histogram {
+  readonly observe: (value: number) => Effect.Effect<void>
+  readonly getStats: () => Effect.Effect<{ count: number; sum: number; min: number; max: number; mean: number }>
+}
+
+export interface TimingResult<A> {
+  readonly value: A
+  readonly durationMs: number
+}
+
+export interface MetricsService {
+  readonly counter: (name: string) => Effect.Effect<Counter>
+  readonly gauge: (name: string) => Effect.Effect<Gauge>
+  readonly histogram: (name: string) => Effect.Effect<Histogram>
+  readonly timed: <A, E, R>(label: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<TimingResult<A>, E, R>
+  readonly snapshot: () => Effect.Effect<MetricsSnapshot>
+}
+
+export interface MetricsSnapshot {
+  readonly counters: ReadonlyArray<{ name: string; value: number }>
+  readonly gauges: ReadonlyArray<{ name: string; value: number }>
+  readonly histograms: ReadonlyArray<{
+    name: string
+    count: number
+    sum: number
+    min: number
+    max: number
+    mean: number
+  }>
+  readonly timings: ReadonlyArray<{ label: string; durationMs: number }>
+}
+
+export interface MetricsServiceId {
+  readonly MetricsService: unique symbol
+}
+
+export const Metrics = Context.GenericTag<MetricsServiceId, MetricsService>("MetricsService")
+
+interface InMemoryState {
+  counters: HashMap.HashMap<string, Ref.Ref<number>>
+  gauges: HashMap.HashMap<string, Ref.Ref<number>>
+  histograms: HashMap.HashMap<string, Ref.Ref<Array<number>>>
+  timings: Ref.Ref<Array<{ label: string; durationMs: number }>>
+}
+
+const makeInMemoryMetrics = (): Effect.Effect<MetricsService> =>
+  Effect.gen(function* () {
+    const stateRef = yield* Ref.make<InMemoryState>({
+      counters: HashMap.empty(),
+      gauges: HashMap.empty(),
+      histograms: HashMap.empty(),
+      timings: yield* Ref.make<Array<{ label: string; durationMs: number }>>([])
+    })
+
+    const getOrCreateCounter = (name: string): Effect.Effect<Ref.Ref<number>> =>
+      Effect.gen(function* () {
+        const state = yield* Ref.get(stateRef)
+        const existing = HashMap.get(state.counters, name)
+        if (existing._tag === "Some") {
+          return existing.value
+        }
+        const newRef = yield* Ref.make(0)
+        yield* Ref.update(stateRef, (s) => ({
+          ...s,
+          counters: HashMap.set(s.counters, name, newRef)
+        }))
+        return newRef
+      })
+
+    const getOrCreateGauge = (name: string): Effect.Effect<Ref.Ref<number>> =>
+      Effect.gen(function* () {
+        const state = yield* Ref.get(stateRef)
+        const existing = HashMap.get(state.gauges, name)
+        if (existing._tag === "Some") {
+          return existing.value
+        }
+        const newRef = yield* Ref.make(0)
+        yield* Ref.update(stateRef, (s) => ({
+          ...s,
+          gauges: HashMap.set(s.gauges, name, newRef)
+        }))
+        return newRef
+      })
+
+    const getOrCreateHistogram = (name: string): Effect.Effect<Ref.Ref<Array<number>>> =>
+      Effect.gen(function* () {
+        const state = yield* Ref.get(stateRef)
+        const existing = HashMap.get(state.histograms, name)
+        if (existing._tag === "Some") {
+          return existing.value
+        }
+        const newRef = yield* Ref.make<Array<number>>([])
+        yield* Ref.update(stateRef, (s) => ({
+          ...s,
+          histograms: HashMap.set(s.histograms, name, newRef)
+        }))
+        return newRef
+      })
+
+    const service: MetricsService = {
+      counter: (name) =>
+        Effect.gen(function* () {
+          const ref = yield* getOrCreateCounter(name)
+          return {
+            inc: (n = 1) => Ref.update(ref, (v) => v + n),
+            get: () => Ref.get(ref)
+          }
+        }),
+
+      gauge: (name) =>
+        Effect.gen(function* () {
+          const ref = yield* getOrCreateGauge(name)
+          return {
+            set: (value) => Ref.set(ref, value),
+            get: () => Ref.get(ref)
+          }
+        }),
+
+      histogram: (name) =>
+        Effect.gen(function* () {
+          const ref = yield* getOrCreateHistogram(name)
+          return {
+            observe: (value) => Ref.update(ref, (arr) => [...arr, value]),
+            getStats: () =>
+              Effect.gen(function* () {
+                const values = yield* Ref.get(ref)
+                if (values.length === 0) {
+                  return { count: 0, sum: 0, min: 0, max: 0, mean: 0 }
+                }
+                const sum = values.reduce((a, b) => a + b, 0)
+                return {
+                  count: values.length,
+                  sum,
+                  min: Math.min(...values),
+                  max: Math.max(...values),
+                  mean: sum / values.length
+                }
+              })
+          }
+        }),
+
+      timed: (label, effect) =>
+        Effect.gen(function* () {
+          const start = yield* Clock.currentTimeMillis
+          const value = yield* effect
+          const end = yield* Clock.currentTimeMillis
+          const durationMs = Number(end - start)
+          const state = yield* Ref.get(stateRef)
+          yield* Ref.update(state.timings, (arr) => [...arr, { label, durationMs }])
+          return { value, durationMs }
+        }),
+
+      snapshot: () =>
+        Effect.gen(function* () {
+          const state = yield* Ref.get(stateRef)
+
+          const counters: Array<{ name: string; value: number }> = []
+          for (const [name, ref] of HashMap.entries(state.counters)) {
+            const value = yield* Ref.get(ref)
+            counters.push({ name, value })
+          }
+
+          const gauges: Array<{ name: string; value: number }> = []
+          for (const [name, ref] of HashMap.entries(state.gauges)) {
+            const value = yield* Ref.get(ref)
+            gauges.push({ name, value })
+          }
+
+          const histograms: Array<{
+            name: string
+            count: number
+            sum: number
+            min: number
+            max: number
+            mean: number
+          }> = []
+          for (const [name, ref] of HashMap.entries(state.histograms)) {
+            const values = yield* Ref.get(ref)
+            if (values.length > 0) {
+              const sum = values.reduce((a, b) => a + b, 0)
+              histograms.push({
+                name,
+                count: values.length,
+                sum,
+                min: Math.min(...values),
+                max: Math.max(...values),
+                mean: sum / values.length
+              })
+            }
+          }
+
+          const timings = yield* Ref.get(state.timings)
+
+          return { counters, gauges, histograms, timings }
+        })
+    }
+
+    return service
+  })
+
+export const InMemoryMetricsLive: Layer.Layer<MetricsServiceId> = Layer.effect(Metrics, makeInMemoryMetrics())
+
+const noOpCounter: Counter = {
+  inc: () => Effect.void,
+  get: () => Effect.succeed(0)
+}
+
+const noOpGauge: Gauge = {
+  set: () => Effect.void,
+  get: () => Effect.succeed(0)
+}
+
+const noOpHistogram: Histogram = {
+  observe: () => Effect.void,
+  getStats: () => Effect.succeed({ count: 0, sum: 0, min: 0, max: 0, mean: 0 })
+}
+
+const noOpMetrics: MetricsService = {
+  counter: () => Effect.succeed(noOpCounter),
+  gauge: () => Effect.succeed(noOpGauge),
+  histogram: () => Effect.succeed(noOpHistogram),
+  timed: (_, effect) => Effect.map(effect, (value) => ({ value, durationMs: 0 })),
+  snapshot: () =>
+    Effect.succeed({
+      counters: [],
+      gauges: [],
+      histograms: [],
+      timings: []
+    })
+}
+
+export const NoOpMetricsLive: Layer.Layer<MetricsServiceId> = Layer.succeed(Metrics, noOpMetrics)
+
+export const counter = (name: string) => Effect.flatMap(Metrics, (metrics) => metrics.counter(name))
+
+export const gauge = (name: string) => Effect.flatMap(Metrics, (metrics) => metrics.gauge(name))
+
+export const histogram = (name: string) => Effect.flatMap(Metrics, (metrics) => metrics.histogram(name))
+
+export const timed = <A, E, R>(label: string, effect: Effect.Effect<A, E, R>) =>
+  Effect.flatMap(Metrics, (metrics) => metrics.timed(label, effect))
+
+export const snapshot = () => Effect.flatMap(Metrics, (metrics) => metrics.snapshot())

package/src/services/Random.ts

@@ -0,0 +1,98 @@
+import * as Effect from "effect/Effect"
+import * as Context from "effect/Context"
+import * as Layer from "effect/Layer"
+
+export interface RandomService {
+  readonly next: () => Effect.Effect<number>
+  readonly nextGaussian: (mean: number, std: number) => Effect.Effect<number>
+  readonly nextInt: (min: number, max: number) => Effect.Effect<number>
+  readonly fork: () => Effect.Effect<RandomService>
+}
+
+export interface RandomServiceId {
+  readonly RandomService: unique symbol
+}
+
+export const Random = Context.GenericTag<RandomServiceId, RandomService>("RandomService")
+
+interface RngState {
+  state: number
+}
+
+const mulberry32Next = (rng: RngState): number => {
+  rng.state = (rng.state + 0x6d2b79f5) >>> 0
+  let t = rng.state
+  t = Math.imul(t ^ (t >>> 15), t | 1)
+  t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+  return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+}
+
+const boxMullerGaussian = (rng: RngState, mean: number, std: number): number => {
+  const u1 = mulberry32Next(rng)
+  const u2 = mulberry32Next(rng)
+  const z0 = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2)
+  return z0 * std + mean
+}
+
+const makeSeededRandom = (seed: number): RandomService => {
+  const rng: RngState = { state: seed >>> 0 }
+
+  const service: RandomService = {
+    next: () => Effect.sync(() => mulberry32Next(rng)),
+
+    nextGaussian: (mean, std) => Effect.sync(() => boxMullerGaussian(rng, mean, std)),
+
+    nextInt: (min, max) =>
+      Effect.sync(() => {
+        const range = max - min
+        return Math.floor(mulberry32Next(rng) * range) + min
+      }),
+
+    fork: () =>
+      Effect.sync(() => {
+        const forkSeed = Math.floor(mulberry32Next(rng) * 0xffffffff)
+        return makeSeededRandom(forkSeed)
+      })
+  }
+
+  return service
+}
+
+const makeSystemRandom = (): RandomService => {
+  const service: RandomService = {
+    next: () => Effect.sync(() => Math.random()),
+
+    nextGaussian: (mean, std) =>
+      Effect.sync(() => {
+        const u1 = Math.random()
+        const u2 = Math.random()
+        const z0 = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2)
+        return z0 * std + mean
+      }),
+
+    nextInt: (min, max) =>
+      Effect.sync(() => {
+        const range = max - min
+        return Math.floor(Math.random() * range) + min
+      }),
+
+    fork: () => Effect.succeed(makeSystemRandom())
+  }
+
+  return service
+}
+
+export const SeededRandomLive = (seed: number): Layer.Layer<RandomServiceId> =>
+  Layer.succeed(Random, makeSeededRandom(seed))
+
+export const SystemRandomLive: Layer.Layer<RandomServiceId> = Layer.succeed(Random, makeSystemRandom())
+
+export const next = () => Effect.flatMap(Random, (random) => random.next())
+
+export const nextGaussian = (mean: number, std: number) =>
+  Effect.flatMap(Random, (random) => random.nextGaussian(mean, std))
+
+export const nextInt = (min: number, max: number) =>
+  Effect.flatMap(Random, (random) => random.nextInt(min, max))
+
+export const fork = () => Effect.flatMap(Random, (random) => random.fork())