@typed/fx 0.0.1

package/src/Layer/Layer.ts

@@ -0,0 +1,44 @@
+import { pipe } from 'hkt-ts/function'
+
+import * as Fx from '@/Fx/Fx.js'
+import { Scope } from '@/Scope/Scope.js'
+import { Service } from '@/Service/Service.js'
+
+// TODO: Global Layers
+// TODO: Refreshing
+// TODO: Combinators for providing fallbacks
+// TODO: Combinators for composing layers
+
+export interface Layer<R, E, A> {
+  readonly service: Service<A>
+  readonly build: (scope: Scope) => Fx.Fx<R, E, A>
+}
+
+export type AnyLayer =
+  | Layer<any, any, any>
+  | Layer<never, never, any>
+  | Layer<never, any, any>
+  | Layer<any, never, any>
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export type ResourcesOf<T> = T extends Layer<infer _R, infer _E, infer _A> ? _R : never
+export type ErrorsOf<T> = T extends Layer<infer _R, infer _E, infer _A> ? _E : never
+export type OutputOf<T> = T extends Layer<infer _R, infer _E, infer _A> ? _A : never
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
+export function Layer<R, E, A>(
+  service: Service<A>,
+  build: Layer<R, E, A>['build'],
+): Layer<R, E, A> {
+  return {
+    service,
+    build,
+  }
+}
+
+export function fromFx<S, R, E, A extends S>(
+  s: Service<S>,
+  fx: Fx.Fx<R | Scope, E, A>,
+): Layer<R, E, S> {
+  return Layer(s, (scope) => pipe(fx, Fx.provideService(Scope, scope)))
+}

package/src/Layer/index.ts

@@ -0,0 +1 @@
+export * from './Layer.js'

package/src/Logger/Console.test.ts

@@ -0,0 +1,10 @@
+import { runTest } from '@/Fx/Fx.test.js'
+import { log, span } from '@/Fx/logging.js'
+
+describe(new URL(import.meta.url).pathname, () => {
+  it('allows logging to the console', async () => {
+    const test = span('foo')(log('test'))
+
+    await runTest(test)
+  })
+})

package/src/Logger/Console.ts

@@ -0,0 +1,85 @@
+import { LogAnnotation } from './LogAnnotation.js'
+import { LogLevel } from './LogLevel.js'
+import { LogSpan } from './LogSpan.js'
+import { Logger } from './Logger.js'
+
+import { Clock, timeToUnixTime } from '@/Clock/index.js'
+import { format, fromTime } from '@/Duration/Duration.js'
+import { Fx, getFiberContext } from '@/Fx/Fx.js'
+import { Time } from '@/Time/index.js'
+
+export const Console: Logger<string, void> = {
+  log: (input, level, id, logSpans, logAnnotations) =>
+    Fx(function* () {
+      if (level === LogLevel.None) {
+        return
+      }
+
+      const { platform } = yield* getFiberContext
+      const now = platform.timer.getCurrentTime()
+
+      const message = [
+        `timestamp=${getIsoString(now, platform.timer)}`,
+        `level=${formatLogLevel(level)}`,
+        `fiber=${id.sequenceNumber}`,
+        ...logSpans.map(formatLogSpan(now)),
+        ...logAnnotations.map(formatlogAnnotation),
+        `message=${input}`,
+      ].join('; ')
+
+      logWithLevel(message, level)
+    }),
+}
+
+function formatLogLevel(level: LogLevel) {
+  switch (level) {
+    case LogLevel.None:
+      return 'none'
+    case LogLevel.Fatal:
+      return 'fatal'
+    case LogLevel.Error:
+      return 'error'
+    case LogLevel.Warn:
+      return 'warn'
+    case LogLevel.Info:
+      return 'info'
+    case LogLevel.Log:
+      return 'log'
+    case LogLevel.Trace:
+      return 'trace'
+    case LogLevel.Debug:
+      return 'debug'
+  }
+}
+
+function logWithLevel(message: string, level: LogLevel) {
+  switch (level) {
+    case LogLevel.Fatal:
+    case LogLevel.Error:
+      return console.error(message)
+    case LogLevel.Warn:
+      return console.warn(message)
+    case LogLevel.Info:
+      return console.info(message)
+    case LogLevel.Log:
+      return console.log(message)
+    case LogLevel.Trace:
+      return console.trace(message)
+    case LogLevel.Debug:
+      return console.debug(message)
+  }
+}
+
+function getIsoString(time: Time, clock: Clock) {
+  return new Date(timeToUnixTime(time)(clock)).toISOString()
+}
+
+function formatLogSpan(now: Time) {
+  return (span: LogSpan) => {
+    return `${span.label}=${format(fromTime(Time(now - span.start)))}`
+  }
+}
+
+function formatlogAnnotation(annotation: LogAnnotation) {
+  return `${annotation.label}=${annotation.value}`
+}

package/src/Logger/LogAnnotation.ts

@@ -0,0 +1,8 @@
+export interface LogAnnotation {
+  readonly label: string
+  readonly value: string
+}
+
+export function LogAnnotation(label: string, value: string): LogAnnotation {
+  return { label, value }
+}

package/src/Logger/LogLevel.ts

@@ -0,0 +1,10 @@
+export enum LogLevel {
+  None,
+  Fatal,
+  Error,
+  Warn,
+  Info,
+  Log,
+  Trace,
+  Debug,
+}

package/src/Logger/LogSpan.ts

@@ -0,0 +1,10 @@
+import { Time } from '@/Time/index.js'
+
+export interface LogSpan {
+  readonly label: string
+  readonly start: Time
+}
+
+export function LogSpan(label: string, start: Time): LogSpan {
+  return { label, start }
+}

package/src/Logger/Logger.ts

@@ -0,0 +1,83 @@
+import { HKT2, Params, pipe } from 'hkt-ts'
+import { Either } from 'hkt-ts/Either'
+import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
+import * as C from 'hkt-ts/Typeclass/Covariant'
+import * as D from 'hkt-ts/Typeclass/Divariant'
+import { Unary } from 'hkt-ts/Unary'
+
+import { LogAnnotation } from './LogAnnotation.js'
+import { LogLevel } from './LogLevel.js'
+import { LogSpan } from './LogSpan.js'
+
+import { FiberId } from '@/FiberId/FiberId.js'
+import * as Fx from '@/Fx/Fx.js'
+
+// TODO: Console as a Logger
+// TODO: Build into Fx runtime
+
+export interface Logger<A, B> {
+  readonly log: (
+    input: A,
+    level: LogLevel,
+    id: FiberId.Live,
+    logSpans: ReadonlyArray<LogSpan>,
+    logAnnotations: ReadonlyArray<LogAnnotation>,
+  ) => Fx.Of<B>
+}
+
+export function Logger<A, B>(log: Logger<A, B>['log']): Logger<A, B> {
+  return { log }
+}
+
+export function both<A, C>(second: Logger<A, C>) {
+  return <B>(first: Logger<A, B>): Logger<A, readonly [B, C]> =>
+    Logger((...args) => Fx.both(second.log(...args))(first.log(...args)))
+}
+
+export function either<A, C>(second: Logger<A, C>) {
+  return <B>(first: Logger<A, B>): Logger<A, Either<B, C>> =>
+    Logger((...args) => Fx.either(second.log(...args))(first.log(...args)))
+}
+
+export interface LoggerHKT extends HKT2 {
+  readonly type: Logger<this[Params.E], this[Params.A]>
+}
+
+export const Divariant: D.Divariant2<LoggerHKT> = {
+  dimap:
+    <A, B, C, D>(f: Unary<A, B>, g: Unary<C, D>) =>
+    (logger: Logger<B, C>) =>
+      Logger((i: A, level, id, logSpans, logAnnotations) =>
+        Fx.map(g)(logger.log(f(i), level, id, logSpans, logAnnotations)),
+      ),
+}
+
+export const dimap = Divariant.dimap
+
+export const contramap = D.contramap(Divariant)
+export const map = D.map(Divariant)
+
+export const Covariant: C.Covariant2<LoggerHKT> = {
+  map,
+}
+
+export const bindTo = C.bindTo(Covariant)
+export const flap = C.flap(Covariant)
+export const mapTo = C.mapTo(Covariant)
+export const tupled = C.tupled(Covariant)
+
+export const filterLogLevel =
+  (predicate: (level: LogLevel) => boolean) =>
+  <A, B>(logger: Logger<A, B>): Logger<A, Maybe<B>> => ({
+    log: (...args): Fx.Of<Maybe<B>> =>
+      Fx.lazy(() => {
+        if (predicate(args[1])) {
+          return pipe(
+            logger.log(...args),
+            Fx.map((a) => Just(a) as Maybe<B>),
+          )
+        }
+
+        return Fx.now<Maybe<B>>(Nothing)
+      }),
+  })

package/src/Logger/index.ts

@@ -0,0 +1 @@
+export * from './Logger.js'

package/src/Platform/Platform.ts

@@ -0,0 +1,42 @@
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { AtomicCounter } from '@/Atomic/AtomicCounter.js'
+import { SetTimeoutTimer } from '@/Timer/SetTimeoutTimer.js'
+import * as Timer from '@/Timer/Timer.js'
+
+export interface Platform {
+  readonly sequenceNumber: AtomicCounter
+  readonly maxOpCount: NonNegativeInteger
+  readonly maxTraceCount: NonNegativeInteger
+  readonly timer: Timer.Timer
+  readonly reportFailure: (message: string) => void
+  readonly fork: () => Platform
+}
+
+export function Platform(
+  sequenceNumber: AtomicCounter = AtomicCounter(),
+  maxOpCount: NonNegativeInteger = NonNegativeInteger(500),
+  maxTraceCount: NonNegativeInteger = NonNegativeInteger(50),
+  timer: Timer.Timer = SetTimeoutTimer(),
+  reportFailure: (message: string) => void = console.error,
+): Platform {
+  const platform: Platform = {
+    sequenceNumber,
+    maxOpCount,
+    maxTraceCount,
+    timer,
+    reportFailure,
+    fork: () => fork(platform),
+  }
+
+  return platform
+}
+
+export function fork(platform: Platform): Platform {
+  return Platform(
+    platform.sequenceNumber,
+    platform.maxOpCount,
+    platform.maxTraceCount,
+    Timer.fork(platform.timer),
+  )
+}

package/src/Platform/TestPlatform.ts

@@ -0,0 +1,14 @@
+import { Platform } from './Platform.js'
+
+import { TestTimer } from '@/Timer/TestTimer.js'
+
+export interface TestPlatform extends Platform {
+  readonly timer: TestTimer
+}
+
+export function TestPlatform(timer: TestTimer = TestTimer()): TestPlatform {
+  return {
+    ...Platform(undefined, undefined, undefined, timer),
+    timer,
+  }
+}

package/src/Platform/index.ts

@@ -0,0 +1,2 @@
+export * from './Platform.js'
+export * from './TestPlatform.js'

package/src/Ref/Ref.test.ts

@@ -0,0 +1,34 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { Ref } from './Ref.js'
+import { atomic } from './atomic.js'
+
+import { runTest } from '@/Fx/Fx.test.js'
+import * as Fx from '@/Fx/index.js'
+
+describe(new URL(import.meta.url).pathname, () => {
+  describe(Ref.name, () => {
+    class Foo extends Ref('Foo', Fx.now(1)) {}
+    class Bar extends Ref('Bar', Fx.now(1)) {}
+
+    const foobar = pipe(
+      Foo.modify((a) => Fx.now([a + 1, a + 1] as const)),
+      Fx.flatMap((foo) =>
+        pipe(
+          Bar.get(),
+          Fx.map((bar) => foo + bar),
+        ),
+      ),
+    )
+
+    describe(atomic.name, () => {
+      it('allows providing for a Ref', async () => {
+        const test = pipe(foobar, Fx.provideLayers(atomic(Foo), atomic(Bar)))
+
+        deepStrictEqual(await runTest(test), 3)
+      })
+    })
+  })
+})

package/src/Ref/Ref.ts

@@ -0,0 +1,76 @@
+import { pipe } from 'hkt-ts'
+import { DeepEquals, Eq } from 'hkt-ts/Typeclass/Eq'
+
+import { Env } from '@/Env/Env.js'
+import * as Fx from '@/Fx/index.js'
+import { Id, InstanceOf } from '@/Service/index.js'
+
+export interface RefApi<R, E, A> {
+  readonly get: Fx.Fx<R, E, A>
+  readonly modify: <R2, E2, B>(
+    f: (a: A) => Fx.Fx<R2, E2, readonly [B, A]>,
+  ) => Fx.Fx<R | R2, E | E2, B>
+}
+
+export type AnyRefApi =
+  | RefApi<any, any, any>
+  | RefApi<never, never, any>
+  | RefApi<never, any, any>
+  | RefApi<any, never, any>
+
+export type Ref<R, E, A> = ReturnType<typeof Ref<any, R, E, A>>
+
+export type AnyRef =
+  | Ref<any, any, any>
+  | Ref<never, never, any>
+  | Ref<never, any, any>
+  | Ref<any, never, any>
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export type ResourcesOf<T> = T extends Ref<infer _R, infer _E, infer _A> ? _R : never
+export type ErrorsOf<T> = T extends Ref<infer _R, infer _E, infer _A> ? _E : never
+export type OutputOf<T> = T extends Ref<infer _R, infer _E, infer _A> ? _A : never
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
+export function Ref<Tag extends string, R, E, A>(
+  tag: Tag,
+  initial: Fx.Fx<R, E, A>,
+  Eq: Eq<A> = DeepEquals,
+) {
+  return class Reference extends Id implements RefApi<R, E, A> {
+    static tag: Tag = tag
+    readonly tag: Tag = tag
+
+    static initial = initial
+    static Eq = Eq
+
+    constructor(readonly get: RefApi<R, E, A>['get'], readonly modify: RefApi<R, E, A>['modify']) {
+      super()
+    }
+
+    static make<S extends AnyRef>(
+      this: S,
+      get: RefApi<R, E, A>['get'],
+      modify: RefApi<R, E, A>['modify'],
+    ): InstanceOf<S> {
+      return new (this as Ref<R, E, A>)(get, modify) as InstanceOf<S>
+    }
+
+    static get<S extends typeof Reference>(this: S): Fx.Fx<R | InstanceOf<S>, E, A> {
+      return pipe(
+        Fx.access((env: Env<InstanceOf<S>>) => env.get(this.id())),
+        Fx.flatMap((r) => r.get),
+      )
+    }
+
+    static modify<S extends typeof Reference, B, R2, E2>(
+      this: S,
+      f: (a: A) => Fx.Fx<R2, E2, readonly [B, A]>,
+    ): Fx.Fx<R | R2 | InstanceOf<S>, E | E2, B> {
+      return pipe(
+        Fx.access((env: Env<InstanceOf<S>>) => env.get(this.id())),
+        Fx.flatMap((r) => r.modify(f)),
+      )
+    }
+  }
+}

package/src/Ref/atomic.ts

@@ -0,0 +1,33 @@
+import { pipe } from 'hkt-ts'
+
+import { AnyRef, ErrorsOf, OutputOf, ResourcesOf } from './Ref.js'
+
+import { Atomic } from '@/Atomic/Atomic.js'
+import { Fx, fromLazy, lazy, map } from '@/Fx/Fx.js'
+import { Layer } from '@/Layer/Layer.js'
+import { Lock, acquire } from '@/Semaphore/Semaphore.js'
+import { InstanceOf } from '@/Service/index.js'
+
+export function atomic<REF extends AnyRef>(
+  ref: REF,
+): Layer<ResourcesOf<REF>, ErrorsOf<REF>, InstanceOf<REF>> {
+  const service = ref.id()
+
+  return Layer(service, () =>
+    Fx(function* () {
+      const atomic = Atomic(yield* ref.initial)
+      const get = fromLazy(atomic.get)
+      const locked = acquire(new Lock())
+      const modify = <R2, E2, B>(
+        f: (a: OutputOf<REF>) => Fx<R2, E2, readonly [B, OutputOf<REF>]>,
+      ): Fx<R2, E2, B> =>
+        pipe(
+          lazy(() => f(atomic.get())),
+          map((computed) => atomic.modify(() => computed)),
+          locked,
+        )
+
+      return new ref(get as any, modify) as any
+    }),
+  )
+}

package/src/Ref/index.ts

@@ -0,0 +1,2 @@
+export * from './atomic.js'
+export * from './Ref.js'

package/src/Schedule/Decision.ts

@@ -0,0 +1,44 @@
+import { Associative } from 'hkt-ts/Typeclass/Associative'
+
+import { Delay } from '@/Time/index.js'
+
+export type Decision = Continue | Done
+
+export class Continue {
+  readonly tag = 'Continue'
+
+  constructor(readonly delay: Delay) {}
+}
+
+export const Done = new (class Done {
+  readonly tag = 'Done'
+})()
+export type Done = typeof Done
+
+export const DecisionUnionAssociative: Associative<Decision> = {
+  concat: (f, s) => {
+    if (f.tag === 'Done' && s.tag === 'Done') {
+      return Done
+    }
+
+    if (f.tag === 'Done') {
+      return s
+    }
+
+    if (s.tag === 'Done') {
+      return f
+    }
+
+    return new Continue(Delay(Math.min(f.delay, s.delay)))
+  },
+}
+
+export const DecisionIntersectionAssociative: Associative<Decision> = {
+  concat: (f, s) => {
+    if (f.tag === 'Done' || s.tag === 'Done') {
+      return Done
+    }
+
+    return new Continue(Delay(Math.max(f.delay, s.delay)))
+  },
+}

package/src/Schedule/Schedule.ts

@@ -0,0 +1,148 @@
+import { Just, match } from 'hkt-ts/Maybe'
+import { makeAssociative } from 'hkt-ts/Tuple'
+import * as Associative from 'hkt-ts/Typeclass/Associative'
+import { Identity } from 'hkt-ts/Typeclass/Identity'
+import { pipe } from 'hkt-ts/function'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import {
+  Continue,
+  Decision,
+  DecisionIntersectionAssociative,
+  DecisionUnionAssociative,
+  Done,
+} from './Decision.js'
+import {
+  ScheduleState,
+  ScheduleStateIntersectionAssociative,
+  ScheduleStateUnionAssociative,
+} from './ScheduleState.js'
+
+import { Delay, Time } from '@/Time/index.js'
+
+const asap = Delay(0)
+const max = Delay(Number.MAX_SAFE_INTEGER)
+
+const stateDecisionUnionAssociative = makeAssociative<ScheduleState, Decision>(
+  ScheduleStateUnionAssociative,
+  DecisionUnionAssociative,
+)
+
+const stateDecisionIntersectionAssociative = makeAssociative(
+  ScheduleStateIntersectionAssociative,
+  DecisionIntersectionAssociative,
+)
+
+export interface Schedule {
+  readonly step: (now: Time, state: ScheduleState) => readonly [ScheduleState, Decision]
+  readonly and: (schedule: Schedule) => Schedule
+  readonly or: (schedule: Schedule) => Schedule
+}
+
+export function Schedule(step: Schedule['step']): Schedule {
+  const schedule: Schedule = {
+    step,
+    and: (other) => and(other)(schedule),
+    or: (other) => or(other)(schedule),
+  }
+
+  return schedule
+}
+
+export const never: Schedule = Schedule((now, state) => [state.step(now), Done])
+
+export const forever: Schedule = Schedule((now, state) => [
+  state.step(now, Just(asap)),
+  new Continue(asap),
+])
+
+export const recurring = (amount: NonNegativeInteger): Schedule =>
+  Schedule((now, state) => [state.step(now), state.iteration < amount ? new Continue(asap) : Done])
+
+export const periodic = (delay: Delay): Schedule =>
+  Schedule((now, state) => [
+    state.step(now, Just(delay)),
+    new Continue(
+      pipe(
+        state.time,
+        match(
+          () => delay,
+          (prev) => accountForTimeDrift(prev, now, delay),
+        ),
+      ),
+    ),
+  ])
+
+const accountForTimeDrift = (previous: Time, now: Time, delay: Delay): Delay => {
+  const expectedTime = previous + delay
+  const drift = expectedTime > now ? expectedTime - now : 0
+
+  return Delay(drift)
+}
+
+export const delayed = (delay: Delay): Schedule => periodic(delay).and(once)
+
+export const spaced = (delay: Delay): Schedule =>
+  Schedule((now, state) => {
+    const spacedDelay = pipe(
+      state.previousDelay,
+      match(
+        () => delay,
+        (n) => Delay(n + delay),
+      ),
+    )
+
+    return [state.step(now, Just(spacedDelay)), new Continue(spacedDelay)]
+  })
+
+export const exponential = (delay: Delay): Schedule =>
+  Schedule((now, state) => {
+    const exponentialDelay = Delay(delay ** (state.iteration + 1))
+
+    return [state.step(now, Just(exponentialDelay)), new Continue(exponentialDelay)]
+  })
+
+export const retries = (retries: NonNegativeInteger): Schedule =>
+  recurring(NonNegativeInteger(retries + 1))
+
+export const once = recurring(NonNegativeInteger(1))
+
+export const or =
+  (second: Schedule) =>
+  (first: Schedule): Schedule =>
+    UnionAssociative.concat(first, second)
+
+export const union = (...schedules: ReadonlyArray<Schedule>): Schedule =>
+  schedules.length === 0 ? never : schedules.reduce((x, y) => or(y)(x))
+
+export const and =
+  (second: Schedule) =>
+  (first: Schedule): Schedule =>
+    IntersectionAssociative.concat(first, second)
+
+export const intersect = (...schedules: ReadonlyArray<Schedule>): Schedule =>
+  schedules.length === 0 ? once : schedules.reduce((x, y) => and(y)(x))
+
+export const UnionAssociative: Associative.Associative<Schedule> = {
+  concat: (f, s) =>
+    Schedule((now, state) =>
+      stateDecisionUnionAssociative.concat(f.step(now, state), s.step(now, state)),
+    ),
+}
+
+export const UnionIdentity: Identity<Schedule> = {
+  ...UnionAssociative,
+  id: Schedule((now, state) => [state.step(now, Just(max)), new Continue(max)]),
+}
+
+export const IntersectionAssociative: Associative.Associative<Schedule> = {
+  concat: (f, s) =>
+    Schedule((now, state) =>
+      stateDecisionIntersectionAssociative.concat(f.step(now, state), s.step(now, state)),
+    ),
+}
+
+export const IntersectionIdentity: Identity<Schedule> = {
+  ...IntersectionAssociative,
+  id: forever,
+}