@typed/fx 0.0.1

package/src/Cause/Renderer.ts

@@ -0,0 +1,289 @@
+import * as M from 'hkt-ts/Maybe'
+import { pipe } from 'hkt-ts/function'
+
+import type { Cause, Expected, Interrupted, Unexpected } from './Cause.js'
+import { prettyStringify } from './prettyStringify.js'
+
+import { Debug as FiberIdDebug } from '@/FiberId/index.js'
+import { Trace, Debug as TraceDebug } from '@/Trace/index.js'
+
+export interface Renderer<E> {
+  readonly renderError: (error: E, hasTrace: boolean) => Lines
+  readonly renderUnknown: (error: unknown, hasTrace: boolean) => Lines
+  readonly renderTrace: TraceRenderer
+}
+
+export type TraceRenderer = (trace: Trace) => string
+
+/**
+ * Each item in the array represents a newline
+ */
+export type Lines = readonly string[]
+
+export type Segment = Sequential | Parallel | Failure
+
+export type Step = Parallel | Failure
+
+export interface Failure {
+  readonly type: 'Failure'
+  readonly lines: Lines
+}
+
+export interface Parallel {
+  readonly type: 'Parallel'
+  readonly all: readonly Sequential[]
+}
+
+export interface Sequential {
+  readonly type: 'Sequential'
+  readonly all: readonly Step[]
+}
+
+export function Failure(lines: readonly string[]): Failure {
+  return {
+    type: 'Failure',
+    lines,
+  }
+}
+
+export function Sequential(all: readonly Step[]): Sequential {
+  return {
+    type: 'Sequential',
+    all,
+  }
+}
+
+export function Parallel(all: readonly Sequential[]): Parallel {
+  return {
+    type: 'Parallel',
+    all,
+  }
+}
+
+export function renderInterrupted<E>(
+  cause: Interrupted,
+  trace: M.Maybe<Trace>,
+  renderer: Renderer<E>,
+): Sequential {
+  return Sequential([
+    Failure([
+      `Interrupted by Fiber ${FiberIdDebug.debug(cause.fiberId)}.`,
+      '',
+      ...renderTrace(trace, renderer),
+    ]),
+  ])
+}
+
+export function renderExpected<E>(
+  cause: Expected<E>,
+  trace: M.Maybe<Trace>,
+  renderer: Renderer<E>,
+) {
+  return Sequential([
+    Failure([
+      'An expected error has occurred.',
+      '',
+      ...renderer.renderError(
+        cause.error,
+        M.isJust(trace) && trace.value.tag !== 'EmptyTrace' && trace.value.frames.length > 0,
+      ),
+      ...renderTrace(trace, renderer),
+    ]),
+  ])
+}
+
+export function renderUnexpected<E>(
+  cause: Unexpected,
+  trace: M.Maybe<Trace>,
+  renderer: Renderer<E>,
+) {
+  return Sequential([
+    Failure([
+      'An unexpected error has occurred.',
+      '',
+      ...renderer.renderUnknown(
+        cause.error,
+        M.isJust(trace) && trace.value.tag !== 'EmptyTrace' && trace.value.frames.length > 0,
+      ),
+      ...renderTrace(trace, renderer),
+    ]),
+  ])
+}
+
+export function renderCauseToSequential<E>(cause: Cause<E>, renderer: Renderer<E>): Sequential {
+  switch (cause.tag) {
+    case 'Empty':
+      return Sequential([])
+    case 'Expected':
+      return renderExpected(cause, M.Nothing, renderer)
+    case 'Unexpected':
+      return renderUnexpected(cause, M.Nothing, renderer)
+    case 'Interrupted':
+      return renderInterrupted(cause, M.Nothing, renderer)
+    case 'Sequential':
+      return Sequential(linearSegments(cause, renderer))
+    case 'Parallel':
+      return Sequential([Parallel(parrallelSegments(cause, renderer))])
+    case 'Traced': {
+      switch (cause.cause.tag) {
+        case 'Expected':
+          return renderExpected(cause.cause, M.Just(cause.trace), renderer)
+        case 'Unexpected':
+          return renderUnexpected(cause.cause, M.Just(cause.trace), renderer)
+        case 'Interrupted':
+          return renderInterrupted(cause.cause, M.Just(cause.trace), renderer)
+        default: {
+          const { all }: Sequential = renderCauseToSequential(cause.cause, renderer)
+          const rendered = renderTrace(M.Just(cause.trace), renderer)
+
+          return Sequential([
+            ...(rendered.every((x) => includes(all, x))
+              ? []
+              : [Failure(['An error was rethrown with a new trace.', ...rendered])]),
+            ...all,
+          ])
+        }
+      }
+    }
+  }
+}
+
+function includes(steps: ReadonlyArray<Step>, value: string): boolean {
+  // Reverse steps as this will usually be at the bottom of the previous section
+  for (const step of steps.slice().reverse()) {
+    if (stepIncludes(step, value)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+function stepIncludes(step: Step, value: string): boolean {
+  switch (step.type) {
+    case 'Failure':
+      return step.lines.includes(value)
+    case 'Parallel':
+      return includes(
+        step.all.flatMap((s) => s.all),
+        value,
+      )
+  }
+}
+
+export function linearSegments<E>(cause: Cause<E>, renderer: Renderer<E>): readonly Step[] {
+  switch (cause.tag) {
+    case 'Sequential':
+      return [...linearSegments(cause.left, renderer), ...linearSegments(cause.right, renderer)]
+    default:
+      return renderCauseToSequential(cause, renderer).all
+  }
+}
+
+export function parrallelSegments<E>(
+  cause: Cause<E>,
+  renderer: Renderer<E>,
+): readonly Sequential[] {
+  switch (cause.tag) {
+    case 'Parallel':
+      return [
+        ...parrallelSegments(cause.left, renderer),
+        ...parrallelSegments(cause.right, renderer),
+      ]
+    default:
+      return [renderCauseToSequential(cause, renderer)]
+  }
+}
+
+export function renderError(error: Error, hasTrace = false): Lines {
+  return hasTrace ? lines(`${error.name}: ${error.message}`) : lines(String(error))
+}
+
+export function renderTrace<E>(trace: M.Maybe<Trace>, renderer: Renderer<E>): Lines {
+  return pipe(
+    trace,
+    M.match(
+      () => [],
+      (trace) => lines(addPadding(renderer.renderTrace(trace))),
+    ),
+  )
+}
+
+export function lines(s: string): Lines {
+  return s.split('\n').map((s) => s.replace('\r', ''))
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function renderString(u: any): string {
+  const s = u?.toString?.()
+  const shouldJsonify = !s || s.trim().startsWith('[object')
+
+  return shouldJsonify ? prettyStringify(u) : s
+}
+
+export function prefixBlock(lines: Lines, headPrefix: string, tailPrefix: string): Lines {
+  if (lines.length === 0) {
+    return []
+  }
+
+  const [head, ...tail] = lines
+
+  return [`${headPrefix}${head}`, ...tail.map((t) => `${tailPrefix}${t}`)]
+}
+
+export function format(segment: Segment): Lines {
+  switch (segment.type) {
+    case 'Failure': {
+      return prefixBlock(segment.lines, '─', ' ')
+    }
+    case 'Parallel': {
+      return [
+        '══╦'.repeat(segment.all.length - 1) + '══╗',
+        ...segment.all.reduceRight(
+          (acc: Lines, current: Sequential): Lines => [
+            ...prefixBlock(acc, '  ║', '  ║'),
+            ...prefixBlock(format(current), '  ', '  '),
+          ],
+          [],
+        ),
+      ]
+    }
+    case 'Sequential': {
+      return segment.all.flatMap((seg) => ['║', ...prefixBlock(format(seg), '╠', '║'), '▼'])
+    }
+  }
+}
+
+export function prettyLines<E>(cause: Cause<E>, renderer: Renderer<E>): Lines {
+  const s = renderCauseToSequential(cause, renderer)
+
+  if (s.all.length === 1 && s.all[0].type === 'Failure') {
+    return s.all[0].lines
+  }
+
+  const formatted = format(s)
+
+  return formatted.length === 0 ? [] : ['╥', ...formatted.slice(1)]
+}
+
+export function defaultErrorToLines(error: unknown, hasTrace = false): Lines {
+  return error instanceof Error ? renderError(error, hasTrace) : lines(renderString(error))
+}
+
+export const defaultRenderer: Renderer<unknown> = {
+  renderError: defaultErrorToLines,
+  renderUnknown: defaultErrorToLines,
+  // Add 4 spaces of padding like most JS runtimes.
+  renderTrace: TraceDebug.debug,
+}
+
+// Add 4-spaces of padding like most JS runtimes do for stack traces.
+function addPadding(s: string): string {
+  return '    ' + s.replace(/\n/g, '\n    ')
+}
+
+export function prettyPrint<E>(cause: Cause<E>, renderer: Renderer<E> = defaultRenderer): string {
+  const lines = prettyLines(cause, renderer)
+
+  return `\n${lines.join('\n')}`.trimEnd()
+}

package/src/Cause/index.ts

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

package/src/Cause/prettyStringify.ts

@@ -0,0 +1,8 @@
+const NEWLINE_REGEX = /\r?\n/g
+
+export function prettyStringify(x: unknown, depth = 2): string {
+  const replacement = '\n'.padEnd(1 + depth, ' ')
+
+  // Optional chain is need for passing `undefined` to JSON.stringify returns `undefined`.
+  return JSON.stringify(x, null, 2)?.replace(NEWLINE_REGEX, replacement) ?? ''
+}

package/src/Clock/Clock.ts

@@ -0,0 +1,82 @@
+import { Lazy } from 'hkt-ts'
+import * as Associative from 'hkt-ts/Typeclass/Associative'
+import { Identity } from 'hkt-ts/Typeclass/Identity'
+
+import { Service } from '@/Service/index.js'
+import { Delay, MAX_UNIX_TIME, MIN_UNIX_TIME, Time, UnixTime } from '@/Time/index.js'
+
+export interface Clock {
+  readonly startTime: UnixTime
+  readonly getCurrentTime: Lazy<Time>
+}
+
+export const Clock = Service<Clock>('Clock')
+
+export function make(startTime: UnixTime, getCurrentTime: Lazy<Time>): Clock {
+  return {
+    startTime,
+    getCurrentTime,
+  }
+}
+
+export function delayToUnixTime(delay: Delay) {
+  return (clock: Clock): UnixTime => UnixTime(clock.startTime + clock.getCurrentTime() + delay)
+}
+
+export function timeToDate(time: Time) {
+  return (clock: Clock): Date => new Date(clock.startTime + time)
+}
+
+export function timeToUnixTime(time: Time) {
+  return (clock: Clock): UnixTime => UnixTime(clock.startTime + time)
+}
+
+export function dateToTime(date: Date) {
+  return (clock: Clock): Time => Time(clock.startTime - date.getTime())
+}
+
+export function addDelay(delay: Delay) {
+  return (clock: Clock): Time => Time(clock.getCurrentTime() + delay)
+}
+
+export function timeToDelay(time: Time) {
+  return (clock: Clock): Delay => Delay(Math.max(0, time - clock.getCurrentTime()))
+}
+
+export function unixTimeToDelay(time: UnixTime) {
+  return (clock: Clock): Delay =>
+    Delay(Math.max(0, time - timeToUnixTime(clock.getCurrentTime())(clock)))
+}
+
+export const UnionAssociative: Associative.Associative<Clock> = {
+  concat: (f, s) => (f.startTime <= s.startTime ? f : s),
+}
+
+export const IntersectionAssociative: Associative.Associative<Clock> =
+  Associative.reverse(UnionAssociative)
+
+export const or =
+  (second: Clock) =>
+  (first: Clock): Clock =>
+    UnionAssociative.concat(first, second)
+
+export const and =
+  (second: Clock) =>
+  (first: Clock): Clock =>
+    IntersectionAssociative.concat(first, second)
+
+export const UnionIdentity: Identity<Clock> = {
+  ...UnionAssociative,
+  id: make(MAX_UNIX_TIME, () => Time(0)),
+}
+
+export const IntersectionIdentity: Identity<Clock> = {
+  ...IntersectionAssociative,
+  id: make(MIN_UNIX_TIME, () => Time(0)),
+}
+
+export function fork(clock: Clock): Clock {
+  const offset = clock.getCurrentTime()
+
+  return make(timeToUnixTime(offset)(clock), () => Time(clock.getCurrentTime() - offset))
+}

package/src/Clock/DateClock.ts

@@ -0,0 +1,9 @@
+import { Clock, make } from './Clock.js'
+
+import { Time, UnixTime } from '@/Time/index.js'
+
+export function DateClock(startTime: Date = new Date()): Clock {
+  const offset = startTime.getTime()
+
+  return make(UnixTime(offset), () => Time(new Date().getTime() - offset))
+}

package/src/Clock/TestClock.ts

@@ -0,0 +1,25 @@
+import { Clock, make } from './Clock.js'
+
+import { Delay, Time, UnixTime } from '@/Time/index.js'
+
+/**
+ * A Clock which provides imperative access to progressing Time forward.
+ */
+export interface TestClock extends Clock {
+  readonly progressTimeBy: (delay: Delay) => Time
+  readonly progressTimeTo: (delay: Time) => Time
+}
+
+export function TestClock(startTime: UnixTime = Date.now()): TestClock {
+  let time: Time = Time(0)
+
+  return {
+    ...make(startTime, () => time),
+    progressTimeBy: (delay: Delay) => {
+      return (time = Time(time + delay))
+    },
+    progressTimeTo: (to: Time) => {
+      return (time = to)
+    },
+  }
+}

package/src/Clock/index.ts

@@ -0,0 +1,3 @@
+export * from './Clock.js'
+export * from './DateClock.js'
+export * from './TestClock.js'

package/src/Disposable/Disposable.ts

@@ -0,0 +1,63 @@
+import { constVoid } from 'hkt-ts'
+
+/**
+ * A Synchronous representation of a Resource that can be disposed of or cancelled.
+ */
+export interface Disposable {
+  readonly dispose: () => void
+}
+
+export function Disposable(dispose: () => void): Disposable {
+  return {
+    dispose,
+  }
+}
+
+export const None: Disposable = {
+  dispose: constVoid,
+}
+
+Disposable.None = None
+
+export function all(...disposables: readonly Disposable[]): Disposable {
+  return Disposable(() => disposables.forEach((d) => d.dispose()))
+}
+
+export interface Settable extends Disposable {
+  readonly isDisposed: () => boolean
+  readonly add: (disposable: Disposable) => Disposable
+}
+
+export function settable(): Settable {
+  return new SettableDisposable()
+}
+
+export class SettableDisposable implements Settable {
+  protected disposables = new Set<Disposable>()
+  protected disposed = false
+
+  readonly isDisposed = () => this.disposed
+
+  readonly add = (d: Disposable) => {
+    if (d === None) {
+      return d
+    }
+
+    if (this.disposed) {
+      d.dispose()
+
+      return None
+    }
+
+    this.disposables.add(d)
+
+    return Disposable(() => this.disposables.delete(d))
+  }
+
+  readonly dispose = () => {
+    this.disposed = true
+    const disposable = all(...Array.from(this.disposables))
+    this.disposables.clear()
+    disposable.dispose()
+  }
+}

package/src/Disposable/index.ts

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

package/src/Duration/Duration.ts

@@ -0,0 +1,125 @@
+import { Delay, Time, UnixTime } from '@/Time/index.js'
+
+/**
+ * TODO: Add support for Month/Year -- how to deal with the variability of each month/year?
+ */
+export enum Unit {
+  Week,
+  Day,
+  Hour,
+  Minute,
+  Second,
+  Milliseconds,
+}
+
+const SECOND_MS = 1000
+const MINUTE_MS = 60 * SECOND_MS
+const HOUR_MS = 60 * MINUTE_MS
+const DAY_MS = 24 * HOUR_MS
+const WEEK_MS = 7 * DAY_MS
+
+export interface Duration<U extends Unit> {
+  readonly value: number
+  readonly unit: U
+}
+
+export function Duration<U extends Unit>(value: number, unit: U): Duration<U> {
+  return {
+    value,
+    unit,
+  }
+}
+
+export function toMilliseconds<U extends Unit>(duration: Duration<U>): Duration<Unit.Milliseconds> {
+  switch (duration.unit) {
+    case Unit.Week:
+      return Duration(duration.value * WEEK_MS, Unit.Milliseconds)
+    case Unit.Day:
+      return Duration(duration.value * DAY_MS, Unit.Milliseconds)
+    case Unit.Hour:
+      return Duration(duration.value * HOUR_MS, Unit.Milliseconds)
+    case Unit.Minute:
+      return Duration(duration.value * WEEK_MS, Unit.Milliseconds)
+    case Unit.Second:
+      return Duration(duration.value * SECOND_MS, Unit.Milliseconds)
+    case Unit.Milliseconds:
+      return Duration(duration.value, Unit.Milliseconds)
+    default:
+      throw new Error(`Unknown Duration Unit: ${duration.unit}`)
+  }
+}
+
+export function toUnit<U2 extends Unit>(unit: U2) {
+  return <U extends Unit>(duration: Duration<U>): Duration<U2> => {
+    const ms = toMilliseconds(duration)
+
+    switch (unit) {
+      case Unit.Week:
+        return Duration(ms.value / WEEK_MS, unit)
+      case Unit.Day:
+        return Duration(ms.value / DAY_MS, unit)
+      case Unit.Hour:
+        return Duration(ms.value / HOUR_MS, unit)
+      case Unit.Minute:
+        return Duration(ms.value / WEEK_MS, unit)
+      case Unit.Second:
+        return Duration(ms.value / SECOND_MS, unit)
+      case Unit.Milliseconds:
+        return Duration(ms.value, unit)
+      default:
+        throw new Error(`Unknown Duration Unit: ${duration.unit}`)
+    }
+  }
+}
+
+export function fromTime(time: Time | Delay | UnixTime): Duration<Unit.Milliseconds> {
+  return Duration(time, Unit.Milliseconds)
+}
+
+export function toTime<U extends Unit>(duration: Duration<U>): Time {
+  return Time(toMilliseconds(duration).value)
+}
+
+export function toDelay<U extends Unit>(duration: Duration<U>): Delay {
+  return Delay(toMilliseconds(duration).value)
+}
+
+export function toUnixTime<U extends Unit>(duration: Duration<U>): UnixTime {
+  return UnixTime(toMilliseconds(duration).value)
+}
+
+const formatOrder = [Unit.Week, Unit.Day, Unit.Hour, Unit.Minute, Unit.Second, Unit.Milliseconds]
+
+// Attempts to format using the largest unit possible
+export function format<U extends Unit>(duration: Duration<U>): string {
+  for (const unit of formatOrder) {
+    const d = toUnit(unit)(duration)
+
+    if (d.value >= 1) {
+      return formatDuration(d)
+    }
+  }
+
+  return formatDuration(duration)
+}
+
+export function formatDuration<U extends Unit>(duration: Duration<U>): string {
+  return `${duration.value}${formatUnit(duration.unit)}`
+}
+
+export function formatUnit(unit: Unit): string {
+  switch (unit) {
+    case Unit.Week:
+      return 'wk'
+    case Unit.Day:
+      return 'day'
+    case Unit.Hour:
+      return 'hr'
+    case Unit.Minute:
+      return 'min'
+    case Unit.Second:
+      return 'sec'
+    case Unit.Milliseconds:
+      return 'ms'
+  }
+}

package/src/Duration/index.ts

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

package/src/Env/Env.ts

@@ -0,0 +1,62 @@
+import { pipe } from 'hkt-ts'
+import * as Maybe from 'hkt-ts/Maybe'
+
+// eslint-disable-next-line import/no-cycle
+import * as FiberRef from '@/FiberRef/index.js'
+// eslint-disable-next-line import/no-cycle
+import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
+import { Fx, Of, fromExit } from '@/Fx/Fx.js'
+// eslint-disable-next-line import/no-cycle
+import { join } from '@/Fx/join.js'
+import { Service } from '@/Service/Service.js'
+
+export interface Env<R> {
+  readonly get: <S extends R>(service: Service<S>) => Of<S>
+}
+
+export function Env<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
+  return {
+    get: get(fiberRefs.fork()), // Always use a snapshot of the FiberRefs to avoid mutability problems.
+  }
+}
+
+function get(fiberRefs: FiberRefs.FiberRefs) {
+  return <S>(id: Service<S>): Of<S> => {
+    return Fx(function* () {
+      const service = pipe(
+        fiberRefs,
+        FiberRefs.maybeGetFiberRefStack(FiberRef.Services),
+        Maybe.flatMap((s) => s.value.get(id)),
+      )
+
+      if (Maybe.isJust(service)) {
+        return service.value as S
+      }
+
+      const layers = FiberRefs.maybeGetFiberRefStack(FiberRef.Layers)(fiberRefs)
+      const layer = pipe(
+        layers,
+        Maybe.flatMap((s) => s.value.get(id)),
+      )
+
+      if (Maybe.isNothing(layers) || Maybe.isNothing(layer)) {
+        throw new Error(`Unable to find Layer or Service for ${id.description}`)
+      }
+
+      const [makeFiber, currentFiber] = layer.value
+
+      if (Maybe.isJust(currentFiber)) {
+        return (yield* fromExit(yield* currentFiber.value.exit)) as S
+      }
+
+      const fiber = makeFiber()
+
+      FiberRefs.setFiberRef(
+        FiberRef.Layers,
+        layers.value.value.set(id, [makeFiber, Maybe.Just(fiber)]),
+      )(fiberRefs)
+
+      return (yield* join(fiber)) as S
+    })
+  }
+}

package/src/Env/index.ts

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