@typed/fx 0.0.1

package/src/Semaphore/Semaphore.ts

@@ -0,0 +1,110 @@
+import { constant } from 'hkt-ts/function'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { MutableFutureQueue } from '@/Future/MutableFutureQueue.js'
+import { wait } from '@/Future/wait.js'
+import { Fx, Of, fromLazy, unit } from '@/Fx/Fx.js'
+import { fiberScoped, managed, scoped } from '@/Fx/scoped.js'
+
+export class Semaphore {
+  protected waiting = MutableFutureQueue<never, never, void>()
+  protected running = 0
+
+  constructor(readonly maxPermits: NonNegativeInteger) {}
+
+  // Retrieve the number of permits still available
+  get available(): NonNegativeInteger {
+    return NonNegativeInteger(Math.max(0, this.maxPermits - this.running))
+  }
+
+  get acquired(): NonNegativeInteger {
+    return NonNegativeInteger(this.running)
+  }
+
+  readonly prepare = fromLazy(() => {
+    if (this.available > 0) {
+      return new Acquisition(
+        fromLazy(() => {
+          this.running++
+        }),
+        this.release,
+      )
+    }
+
+    const [future] = this.waiting.waitFor(1)
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this
+    const acquisition = new Acquisition(
+      Fx(function* () {
+        yield* wait(future)
+
+        that.running++
+      }),
+      this.release,
+    )
+
+    return acquisition
+  })
+
+  protected release = fromLazy(() => {
+    this.running = Math.max(0, this.running - 1)
+
+    if (this.waiting.size() > 0) {
+      this.waiting.next(unit)
+    }
+  })
+}
+
+export class Acquisition {
+  constructor(readonly acquire: Of<void>, readonly release: Of<void>) {}
+}
+
+/**
+ * Specialization of Semaphore which only allows 1 permit.
+ */
+export class Lock extends Semaphore {
+  constructor() {
+    super(NonNegativeInteger(1))
+  }
+}
+
+/**
+ * Acquire a permit from a given semaphore, blocking until it is available.
+ * Must be used with Fx.scoped() to release the permit at the desired time.
+ */
+export function acquirePermit(semaphore: Semaphore) {
+  return Fx(function* () {
+    const { acquire, release } = yield* semaphore.prepare
+
+    return yield* managed(acquire, constant(release))
+  })
+}
+
+/**
+ * Acquire a permit from a given semaphore, run an Fx, and then release the permit.
+ */
+export function acquire(semaphore: Semaphore) {
+  return <R, E, A>(fx: Fx<R, E, A>) =>
+    scoped(
+      Fx(function* () {
+        yield* acquirePermit(semaphore)
+
+        return yield* fx
+      }),
+    )
+}
+
+/**
+ * Acquire a permit from a given semaphore, run an Fx, and then release the permit.
+ */
+export function acquireFiber(semaphore: Semaphore) {
+  return <R, E, A>(fx: Fx<R, E, A>) =>
+    fiberScoped(
+      Fx(function* () {
+        yield* acquirePermit(semaphore)
+
+        return yield* fx
+      }),
+    )
+}

package/src/Semaphore/index.ts

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

package/src/Service/Id.ts

@@ -0,0 +1,87 @@
+import { Service } from './Service.js'
+
+import { Fx, RIO, ask } from '@/Fx/Fx.js'
+import * as Layer from '@/Layer/Layer.js'
+import { Scope } from '@/Scope/Scope.js'
+
+const idCache = new WeakMap<object, Service<any>>()
+
+export type InstanceOf<T> = T extends new (...args: any) => infer R ? R : T
+
+/**
+ * Extendable class for constructing a Service
+ */
+export class Id {
+  readonly name: string = this.constructor.name
+
+  /**
+   * The ID of the Service.
+   *
+   * Unfortunately, in order to get type-inference the way we'd like this must
+   * currently be a method to access the "this" type in sub-classes.
+   */
+  static id<S extends { readonly name: string }>(this: S): Service<InstanceOf<S>> {
+    return getCachedId(this)
+  }
+
+  // Replicate the same ID to the instance.
+  readonly id: Service<this> = (this.constructor as any).id()
+
+  /**
+   * Retrieve this service at Runtime, requiring it from the given Environment.
+   */
+  static ask<
+    S extends {
+      readonly id: () => Service<any>
+      new (...args: any): any
+    },
+  >(this: S): RIO<InstanceOf<S>, InstanceOf<S>> {
+    return ask(this.id())
+  }
+
+  /**
+   * Construct a Layer that provides this service.
+   */
+  static layer<
+    S extends {
+      readonly id: () => Service<any>
+      new (...args: any): any
+    },
+    R,
+    E,
+  >(this: S, provider: Fx<R | Scope, E, InstanceOf<S>>): Layer.Layer<R, E, InstanceOf<S>> {
+    return Layer.fromFx(this.id(), provider)
+  }
+}
+
+/**
+ * Helper for constructing IDs that are tied to a particular object, which much have
+ * a name to create the Service Key. Particularly useful for creating Class declarations for Services.
+ *
+ * @example
+ * import * as S from '@typed/fx/Service'
+ * import * as Fx from '@typed/fx/Fx'
+ *
+ * class Foo {
+ *   static id = S.getCachedId(this)
+ *
+ *   constructor(readonly foo: string) {}
+ * }
+ *
+ * const program = Fx.Fx(function*(){
+ *   const { foo }: Foo = yield* Fx.ask(Foo.id)
+ *a
+ *   return foo // string
+ * })
+ */
+export function getCachedId<S extends { readonly name: string }>(key: S): Service<InstanceOf<S>> {
+  if (idCache.has(key)) {
+    return idCache.get(key) as Service<InstanceOf<S>>
+  }
+
+  const s = Service<InstanceOf<S>>(key.name)
+
+  idCache.set(key, s)
+
+  return s
+}

package/src/Service/Service.ts

@@ -0,0 +1,31 @@
+import { Tagged } from '@/Tagged/index.js'
+
+/**
+ * The Definition/ID of a Service
+ */
+export type Service<S> = Tagged<
+  {
+    readonly Service: S
+  },
+  symbol
+>
+
+/**
+ * Construct a Service, the provided name is used for debugging purposes and is required.
+ */
+export const Service = <S>(name: string): Service<S> => Tagged<Service<S>>()(Symbol(name))
+
+/**
+ * Extract the output of a Service
+ */
+export type OutputOf<T> = [T] extends [Service<infer S>] ? S : never
+
+const symbolRegex = /^Symbol/i
+const serviceText = 'Service'
+
+/**
+ * Format a Service's into a string.
+ */
+export function formatService<A>(service: Service<A>) {
+  return service.toString().replace(symbolRegex, serviceText)
+}

package/src/Service/index.ts

@@ -0,0 +1,3 @@
+export * from './Service.js'
+export * from './Id.js'
+export * from './tagged.js'

package/src/Service/tagged.ts

@@ -0,0 +1,10 @@
+import { Id } from './Id.js'
+
+/**
+ * Sometimes it is necessary to tag a Service to ensure it is considered different from another at the type-level.
+ */
+export const tagged = <Tag extends string>(tag: Tag) =>
+  class TaggedService extends Id {
+    static tag: Tag = tag
+    readonly tag: Tag = tag
+  }

package/src/Sink/Sink.ts

@@ -0,0 +1,65 @@
+import { flow, pipe } from 'hkt-ts'
+import { Left, Right } from 'hkt-ts/Either'
+
+import { Cause } from '@/Cause/Cause.js'
+import { Fx, IO, getEnv, provide, unit } from '@/Fx/Fx.js'
+import { Closeable } from '@/Scope/Closeable.js'
+
+export interface Sink<E, A> {
+  readonly event: (a: A) => IO<E, any>
+  readonly error: (cause: Cause<E>) => IO<E, any>
+  readonly end: IO<E, any>
+}
+
+export class Drain<E, A> implements Sink<E, A> {
+  constructor(readonly scope: Closeable) {}
+
+  readonly event: Sink<E, A>['event'] = () => unit as IO<E, any>
+  readonly error: Sink<E, A>['error'] = (cause) => this.scope.close(Left(cause)) as IO<E, any>
+  readonly end: Sink<E, A>['end'] = this.scope.close(Right(undefined)) as IO<E, any>
+}
+
+export interface SinkFx<
+  E,
+  A,
+  R2 = never,
+  E2 = never,
+  R3 = never,
+  E3 = never,
+  R4 = never,
+  E4 = never,
+> {
+  readonly event?: (a: A) => Fx<R2, E2, any>
+  readonly error?: (cause: Cause<E>) => Fx<R3, E3, any>
+  readonly end?: Fx<R4, E4, any>
+}
+
+export function makeDrain<
+  E,
+  A,
+  R2 = never,
+  E2 = never,
+  R3 = never,
+  E3 = never,
+  R4 = never,
+  E4 = never,
+>(
+  scope: Closeable,
+  fx: SinkFx<E, A, R2, E2, R3, E3, R4, E4>,
+): Fx<R2 | R3 | R4, never, Sink<E | E2 | E3 | E4, A>> {
+  return Fx(function* () {
+    const env = yield* getEnv<R2 | R3 | R4>()
+    const drain = new Drain<E, A>(scope)
+
+    type O = Sink<E | E2 | E3 | E4, A>
+
+    // TODO: Should drain always be called for error + end?
+    const sink: O = {
+      event: (fx.event ? flow(fx.event, provide(env)) : drain.event) as O['event'],
+      error: (fx.error ? flow(fx.error, provide(env)) : drain.error) as O['error'],
+      end: (fx.end ? pipe(fx.end, provide(env)) : drain.end) as O['end'],
+    }
+
+    return sink
+  })
+}

package/src/Stack/index.ts

@@ -0,0 +1,88 @@
+import { pipe } from 'hkt-ts'
+import { NonEmptyArray, map } from 'hkt-ts/NonEmptyArray'
+import * as Assoc from 'hkt-ts/Typeclass/Associative'
+import * as E from 'hkt-ts/Typeclass/Eq'
+import { Identity } from 'hkt-ts/Typeclass/Identity'
+
+export class Stack<A> {
+  constructor(readonly value: A, readonly previous: Stack<A> | null = null) {}
+
+  readonly push = (value: A): Stack<A> => new Stack(value, this)
+  readonly pop = (): Stack<A> | null => this.previous
+  readonly replace = (f: (value: A) => A): Stack<A> => new Stack(f(this.value), this.previous);
+
+  *[Symbol.iterator]() {
+    yield this.value
+
+    let current = this.previous
+    while (current) {
+      yield current.value
+      current = current.previous
+    }
+  }
+}
+
+export const makeEq = <A>(A: E.Eq<A>): E.Eq<Stack<A>> => {
+  const eq: E.Eq<Stack<A>> = E.struct({
+    value: A,
+    previous: E.nullable(E.lazy(() => eq)),
+  })
+
+  return eq
+}
+
+export function toNonEmptyArray<A>(stack: Stack<A>): NonEmptyArray<A> {
+  return Array.from(stack) as any
+}
+
+export function fromNonEmptyArray<A>(a: NonEmptyArray<A>): Stack<A> {
+  return a
+    .slice(0, a.length - 1)
+    .reduceRight((prev, a) => new Stack(a, prev), new Stack(a[a.length - 1]))
+}
+
+export const join =
+  <A>(AssocA: Assoc.Associative<A>) =>
+  (second: Stack<A>) =>
+  (first: Stack<A>): Stack<A> => {
+    const f = toNonEmptyArray(first)
+    const fl = f.length
+    const s = toNonEmptyArray(second)
+    const sl = s.length
+
+    if (fl === 0) {
+      return second
+    }
+
+    if (sl === 0) {
+      return first
+    }
+
+    // Fast-path for stacks that are equal in size
+    if (fl === sl) {
+      return pipe(
+        f,
+        map((a, i) => AssocA.concat(a, s[i])),
+        fromNonEmptyArray,
+      )
+    }
+
+    const hi = fl > sl ? f : s
+    const lo = fl < sl ? s : f
+    const diff = hi.length - lo.length
+    const join = fl > sl ? AssocA.concat : Assoc.reverse(AssocA).concat
+    const toPrepend = lo.slice(0, diff)
+    const toConcat = hi.slice(diff)
+
+    return fromNonEmptyArray([...toPrepend, ...toConcat.map((a, i) => join(a, lo[i]))] as any)
+  }
+
+export const makeAssociative = <A>(AssocA: Assoc.Associative<A>): Assoc.Associative<Stack<A>> => ({
+  concat: (f, s) => join(AssocA)(f)(s),
+})
+
+// takes an Identity<A> and returns an Identity<Stack<A>>
+export const makeIdentity = <A>(I: Identity<A>): Identity<Stack<A>> => ({
+  ...makeAssociative(I),
+  id: new Stack(I.id),
+})

package/src/StackFrame/StackFrame.ts

@@ -0,0 +1,68 @@
+import * as D from 'hkt-ts/Typeclass/Debug'
+import * as E from 'hkt-ts/Typeclass/Eq'
+import * as O from 'hkt-ts/Typeclass/Ord'
+import * as N from 'hkt-ts/number'
+import * as S from 'hkt-ts/string'
+
+export type StackFrame = InstrumentedStackFrame | RuntimeStackFrame | CustomStackFrame
+
+export interface InstrumentedStackFrame {
+  readonly tag: 'Instrumented'
+  readonly file: string
+  readonly method: string
+  readonly line: number
+  readonly column: number
+}
+
+export interface RuntimeStackFrame {
+  readonly tag: 'Runtime'
+  readonly file: string
+  readonly method: string
+  readonly line: number
+  readonly column: number
+}
+
+export interface CustomStackFrame {
+  readonly tag: 'Custom'
+  readonly trace: string
+}
+
+export const Eq: E.Eq<StackFrame> = E.sum<StackFrame>()('tag')({
+  Instrumented: E.struct({
+    tag: E.AlwaysEqual,
+    file: S.Eq,
+    method: S.Eq,
+    line: N.Eq,
+    column: N.Eq,
+  }),
+  Runtime: E.struct({
+    tag: E.AlwaysEqual,
+    file: S.Eq,
+    method: S.Eq,
+    line: N.Eq,
+    column: N.Eq,
+  }),
+  Custom: E.struct({
+    tag: E.AlwaysEqual,
+    trace: S.Eq,
+  }),
+})
+
+export const Ord: O.Ord<StackFrame> = O.Static
+
+export const Debug: D.Debug<StackFrame> = {
+  debug: (frame) =>
+    frame.tag === 'Custom'
+      ? frame.trace
+      : `at ${frame.method} (${frame.file}${frame.line > -1 ? `:${frame.line}` : ``}${
+          frame.column > -1 ? `:${frame.column}` : ``
+        })`,
+}
+
+export const debug = Debug.debug
+
+export type StackFrames = ReadonlyArray<StackFrame>
+
+export const StackFramesDebug: D.Debug<StackFrames> = {
+  debug: (frames) => frames.map(debug).join('\n'),
+}

package/src/StackFrame/getStackFrames.test.ts

@@ -0,0 +1,30 @@
+import { deepEqual, ok } from 'assert'
+import { dirname } from 'path'
+
+import { isJust } from 'hkt-ts/Maybe'
+
+import { getCurrentStackFrame, getStackFrames } from './getStackFrames.js'
+
+const filename = new URL(import.meta.url).pathname
+const root = dirname(dirname(dirname(filename))) + '/'
+
+describe(filename, function () {
+  describe(getStackFrames.name, function () {
+    it('returns stack frames from an error', function test() {
+      const frame = getCurrentStackFrame() // Provide this for some consistency in the return
+
+      ok(isJust(frame))
+
+      deepEqual(
+        { ...frame.value, file: frame.value.file.replace(`${root}`, '') },
+        {
+          tag: 'Runtime',
+          file: 'src/StackFrame/getStackFrames.ts',
+          method: 'getCurrentStackFrame',
+          line: 47,
+          column: 11,
+        },
+      )
+    })
+  })
+})

package/src/StackFrame/getStackFrames.ts

@@ -0,0 +1,70 @@
+import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
+
+import type { RuntimeStackFrame } from './StackFrame.js'
+import { parseChrome } from './parseChromeStack.js'
+import { parseGecko } from './parseGeckoStackFrame.js'
+
+export function getStackFrames<E extends { stack?: string } = Error>(
+  error: E = {} as E,
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  targetObject?: Function,
+): ReadonlyArray<RuntimeStackFrame> {
+  if (!error.stack && Error.captureStackTrace) {
+    Error.captureStackTrace(error, targetObject)
+  }
+
+  const stack = error.stack
+
+  if (!stack) {
+    return []
+  }
+
+  const stackFrames = stack
+    .split('\n')
+    .map((x) => x.trim())
+    .filter((x) => x.length !== 0)
+    .flatMap((s) => {
+      const frame = parseChrome(s) || parseGecko(s)
+
+      return frame ? [frame] : []
+    })
+
+  // Append all of the parents traces
+  if (error instanceof Error && error.cause) {
+    return [...stackFrames, ...getStackFrames(error.cause)]
+  }
+
+  return stackFrames
+}
+
+export function getCurrentStackFrame(
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  targetObject?: Function,
+): Maybe<RuntimeStackFrame> {
+  const error = new Error()
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(error, targetObject)
+  }
+
+  const stack = error.stack
+
+  if (!stack) {
+    return Nothing
+  }
+
+  const frames = stack
+    .split('\n')
+    .map((x) => x.trim())
+    .filter((x) => x.length !== 0)
+
+  for (const line of frames) {
+    const frame = parseChrome(line) || parseGecko(line)
+
+    if (frame) {
+      return Just(frame)
+    }
+  }
+
+  return Nothing
+}

package/src/StackFrame/index.ts

@@ -0,0 +1,2 @@
+export * from './getStackFrames.js'
+export * from './StackFrame.js'

package/src/StackFrame/parseChromeStack.ts

@@ -0,0 +1,43 @@
+import { RuntimeStackFrame } from './StackFrame.js'
+
+const chromeRe =
+  /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i
+const chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/
+
+export function parseChrome(line: string): RuntimeStackFrame | null {
+  const parts = chromeRe.exec(line)
+
+  if (!parts) {
+    return null
+  }
+
+  const isNative = parts[2] && parts[2].indexOf('native') === 0 // start of line
+  const isEval = parts[2] && parts[2].indexOf('eval') === 0 // start of line
+
+  const submatch = chromeEvalRe.exec(parts[2])
+
+  if (isEval && submatch != null) {
+    // throw out eval line/column and use top-most line/column number
+    parts[2] = submatch[1] // url
+    parts[3] = submatch[2] // line
+    parts[4] = submatch[3] // column
+  }
+
+  return {
+    tag: 'Runtime',
+    file: !isNative ? parseRealFilename(parts[2]) : '',
+    method: parts[1] || '',
+    line: parts[3] ? +parts[3] : -1,
+    column: parts[4] ? +parts[4] : -1,
+  }
+}
+
+function parseRealFilename(s: string): string {
+  if (s.startsWith('file:/')) {
+    const x = s.split(/file:/g)
+
+    return x[x.length - 1]
+  }
+
+  return s
+}

package/src/StackFrame/parseGeckoStackFrame.ts

@@ -0,0 +1,31 @@
+import { RuntimeStackFrame } from './StackFrame.js'
+
+const geckoRe =
+  /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i
+const geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i
+
+export function parseGecko(line: string): RuntimeStackFrame | null {
+  const parts = geckoRe.exec(line)
+
+  if (!parts) {
+    return null
+  }
+
+  const isEval = parts[3] && parts[3].indexOf(' > eval') > -1
+
+  const submatch = geckoEvalRe.exec(parts[3])
+  if (isEval && submatch != null) {
+    // throw out eval line/column and use top-most line number
+    parts[3] = submatch[1]
+    parts[4] = submatch[2]
+    parts[5] = '-1' // no column when eval
+  }
+
+  return {
+    tag: 'Runtime',
+    file: parts[3],
+    method: parts[1] || '',
+    line: parts[4] ? +parts[4] : -1,
+    column: parts[5] ? +parts[5] : 0,
+  }
+}

package/src/Stream/Stream.ts

@@ -0,0 +1,21 @@
+import { Live } from '@/Fiber/Fiber.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import * as Fx from '@/Fx/Fx.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+
+export interface Stream<R, E, A> {
+  readonly fork: <E2>(
+    sink: Sink<E | E2, A>,
+    scheduler: Scheduler,
+    context: FiberContext,
+  ) => Fx.RIO<R, Live<E | E2, any>>
+}
+
+export interface RIO<R, A> extends Stream<R, never, A> {}
+export interface IO<E, A> extends Stream<never, E, A> {}
+export interface Of<A> extends Stream<never, never, A> {}
+
+export function Stream<R, E, A>(fork: Stream<R, E, A>['fork']) {
+  return { fork }
+}