@typed/fx 0.0.6 → 0.0.9

package/src/Stack/index.ts

@@ -1,88 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

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

package/src/StackFrame/parseChromeStack.ts

@@ -1,43 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,55 +0,0 @@
-import { Fiber } from '@/Fiber/Fiber.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import * as Fx from '@/Fx/Fx.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
-
-/**
- * TODOS:
- * - Loop
- * - zipItems
- * - withItems
- * - concatMap
- * - combine/combineArray
- * - zip/zipArray
- * - sample
- * - snapshot
- * - skipRepeats
- * - slice/take/skip
- * - takeWhile/skipWhile
- * - takeUntil/skipUntil
- * - takeAfter/skipAfter
- * - since
- * - during
- * - until
- * - delay
- * - throttle
- * - debounce
- * - reduce
- * - Fusion/Commutation
- * - Unique Identification for streams to add to tracing
- *    - How to build a dynamic stream graph?
- */
-
-export interface Stream<out R = never, out E = never, out A = unknown> {
-  fork<E2 = never>(
-    sink: Sink<E, A, E2>,
-    scheduler: Scheduler,
-    context: FiberContext<FiberId.Live>,
-  ): Fx.RIO<R, Fiber<E2, any>>
-}
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-export type ResourcesOf<T> = T extends Stream<infer R, infer _, infer __> ? R : never
-export type ErrorsOf<T> = T extends Stream<infer _, infer E, infer __> ? E : never
-export type OutputOf<T> = T extends Stream<infer _, infer __, infer A> ? A : never
-/* eslint-enable @typescript-eslint/no-unused-vars */
-
-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']): Stream<R, E, A> {
-  return { fork }
-}

package/src/Stream/_internal.test.ts

@@ -1,12 +0,0 @@
-import { pipe } from 'hkt-ts/function'
-
-import { Stream } from './Stream.js'
-import { collect } from './drain.js'
-
-import * as Fx from '@/Fx/Fx.js'
-import { runMain } from '@/Fx/run.js'
-import { RootScheduler } from '@/Scheduler/RootScheduler.js'
-import { Scheduler } from '@/Scheduler/index.js'
-
-export const collectAll = <E, A>(stream: Stream<never, E, A>) =>
-  pipe(collect(stream), Fx.provideService(Scheduler, RootScheduler()), runMain)

package/src/Stream/acquirePermit.ts

@@ -1,32 +0,0 @@
-import { pipe } from 'hkt-ts/function'
-
-import { Stream } from './Stream.js'
-
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { Live } from '@/FiberId/FiberId.js'
-import * as Fx from '@/Fx/Fx.js'
-import { Scheduler } from '@/Scheduler/index.js'
-import * as Semaphore from '@/Semaphore/index.js'
-import { Sink } from '@/Sink/Sink.js'
-
-export function acquirePermit(semaphore: Semaphore.Semaphore) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> =>
-    new AcquirePermitStream(stream, semaphore)
-}
-
-export class AcquirePermitStream<R, E, A> implements Stream<R, E, A> {
-  constructor(readonly stream: Stream<R, E, A>, readonly semaphore: Semaphore.Semaphore) {}
-
-  fork = <E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<Live>) =>
-    pipe(
-      this.semaphore.prepare,
-      Fx.flatMap(({ acquire, release }) =>
-        pipe(
-          acquire,
-          Fx.uninterruptable,
-          Fx.tapLazy(() => context.scope.ensuring(() => release)),
-          Fx.flatMap(() => this.stream.fork(sink, scheduler, context)),
-        ),
-      ),
-    )
-}

package/src/Stream/bimap.ts

@@ -1,66 +0,0 @@
-import { flow } from 'hkt-ts/function'
-
-import { Stream } from './Stream.js'
-import { MapStream } from './map.js'
-
-import * as Cause from '@/Cause/index.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { Live } from '@/FiberId/FiberId.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
-
-export function bimap<A, B, C, D>(
-  f: (a: A) => B,
-  g: (c: C) => D,
-  __trace?: string,
-): <R>(stream: Stream<R, A, C>) => Stream<R, B, D> {
-  return (stream) => BimapStream.make(stream, f, g, __trace)
-}
-
-export class BimapStream<R, A, B, C, D> implements Stream<R, B, D> {
-  constructor(
-    readonly stream: Stream<R, A, C>,
-    readonly f: (a: A) => B,
-    readonly g: (c: C) => D,
-    readonly __trace?: string,
-  ) {}
-
-  fork = <E>(sink: Sink<B, D, E>, scheduler: Scheduler, context: FiberContext<Live>) => {
-    return this.stream.fork<E>(
-      new BimapSink(sink, scheduler, context, this.f, this.g),
-      scheduler,
-      context,
-    )
-  }
-
-  static make<R, A, B, C, D>(
-    stream: Stream<R, A, C>,
-    f: (a: A) => B,
-    g: (c: C) => D,
-    __trace?: string,
-  ): Stream<R, B, D> {
-    if (stream instanceof MapStream) {
-      return BimapStream.make(stream.stream, f, flow(stream.f, g), __trace)
-    }
-
-    if (stream instanceof BimapStream) {
-      return BimapStream.make(stream.stream, flow(stream.f, f), flow(stream.g, g), __trace)
-    }
-
-    return new BimapStream(stream, f, g, __trace)
-  }
-}
-
-class BimapSink<A, B, C, D, E> implements Sink<A, C, E> {
-  constructor(
-    readonly sink: Sink<B, D, E>,
-    readonly scheduler: Scheduler,
-    readonly context: FiberContext<Live>,
-    readonly f: (a: A) => B,
-    readonly g: (c: C) => D,
-  ) {}
-
-  event = flow(this.g, this.sink.event)
-  error = flow(Cause.map(this.f), this.sink.error)
-  end = this.sink.end
-}

package/src/Stream/continueWith.test.ts

@@ -1,23 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { pipe } from 'hkt-ts'
-
-import { collectAll } from './_internal.test.js'
-import { continueWith } from './continueWith.js'
-import { now } from './fromFx.js'
-
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  describe(continueWith.name, () => {
-    const stream = pipe(
-      now(1),
-      continueWith(() => now(2)),
-    )
-    it('should continue with the provided stream', async () => {
-      const events = await collectAll(stream)
-
-      deepStrictEqual(events, [1, 2])
-    })
-  })
-})

package/src/Stream/continueWith.ts

@@ -1,69 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import { Stream } from './Stream.js'
-import { now } from './fromFx.js'
-
-import { Env } from '@/Env/Env.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import * as Fx from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink, addTrace } from '@/Sink/Sink.js'
-
-export function continueWith<R2, E2, B>(f: () => Stream<R2, E2, B>, __trace?: string) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, A | B> =>
-    new ContinueWith(stream, f, __trace)
-}
-
-export const startWith =
-  <B>(value: B, __trace?: string) =>
-  <R, E, A>(stream: Stream<R, E, A>) =>
-    pipe(
-      now(value),
-      continueWith(() => stream, __trace),
-    )
-
-export class ContinueWith<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2, A | B> {
-  constructor(
-    readonly stream: Stream<R, E, A>,
-    readonly f: () => Stream<R2, E2, B>,
-    readonly __trace?: string,
-  ) {}
-
-  fork = <E3>(
-    sink: Sink<E | E2, A | B, E3>,
-    scheduler: Scheduler,
-    context: FiberContext<FiberId.Live>,
-  ) => {
-    return Fx.access((env: Env<R | R2>) =>
-      this.stream.fork(
-        addTrace(new ContinueWithSink(sink, scheduler, context, env, this.f), this.__trace),
-        scheduler,
-        context,
-      ),
-    )
-  }
-}
-
-export class ContinueWithSink<R, E, A, R2, E2, B, E3> implements Sink<E | E2, A | B, E3> {
-  constructor(
-    readonly sink: Sink<E | E2, A | B, E3>,
-    readonly scheduler: Scheduler,
-    readonly context: FiberContext<FiberId.Live>,
-    readonly env: Env<R | R2>,
-    readonly f: () => Stream<R2, E2, B>,
-  ) {}
-
-  event = this.sink.event
-  error = this.sink.error
-  end = Fx.lazy(() =>
-    pipe(
-      this.f().fork(
-        this.sink,
-        this.scheduler,
-        this.context.fork({ fiberRefs: this.context.fiberRefs }),
-      ),
-      Fx.provide(this.env),
-    ),
-  )
-}

package/src/Stream/drain.ts

@@ -1,60 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import { Stream } from './Stream.js'
-
-import { Fiber } from '@/Fiber/Fiber.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import * as Fx from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Drain, Sink, addTrace, makeDrain } from '@/Sink/Sink.js'
-
-export function drain<R, E, A>(
-  stream: Stream<R, E, A>,
-  __trace?: string,
-): Fx.Fx<R | Scheduler, never, Fiber<never, any>> {
-  return pipe(
-    Fx.Do,
-    Fx.bind('fiberContext', () => Fx.getFiberContext),
-    Fx.let('context', ({ fiberContext }) => fiberContext.fork()),
-    Fx.let('sink', ({ context }) => new Drain<E, A>(context.scope)),
-    Fx.flatMap(({ sink, context }) => fork(stream, sink, context, __trace), __trace),
-  )
-}
-
-export function fork<R, E, A, E2 = never>(
-  stream: Stream<R, E, A>,
-  sink: Sink<E, A, E2>,
-  context: FiberContext<FiberId.Live>,
-  __trace?: string,
-): Fx.Fx<R | Scheduler, never, Fiber<E2, A>> {
-  return Fx.asks(Scheduler)((scheduler) => stream.fork(addTrace(sink, __trace), scheduler, context))
-}
-
-export function observe<A, R2, E2, B>(f: (a: A) => Fx.Fx<R2, E2, B>, __trace?: string) {
-  return <R, E>(stream: Stream<R, E, A>): Fx.Fx<R | R2 | Scheduler, never, Fiber<E | E2, A>> =>
-    pipe(
-      Fx.Do,
-      Fx.bind('fiberContext', () => Fx.getFiberContext),
-      Fx.let('context', ({ fiberContext }) => fiberContext.fork()),
-      Fx.bind('sink', ({ context }) => makeDrain<E, A, R2, E2>(context.scope, { event: f })),
-      Fx.flatMap(({ sink, context }) => fork(stream, sink, context, __trace), __trace),
-    )
-}
-
-export function collect<R, E, A>(
-  stream: Stream<R, E, A>,
-  __trace?: string,
-): Fx.Fx<R | Scheduler, E, readonly A[]> {
-  return Fx.Fx(function* () {
-    const events: A[] = []
-
-    yield* pipe(
-      stream,
-      observe((a) => Fx.fromLazy(() => events.push(a)), __trace),
-      Fx.flatMap(Fx.join),
-    )
-
-    return events
-  }, __trace)
-}

package/src/Stream/empty.ts

@@ -1,7 +0,0 @@
-import { Stream } from './Stream.js'
-
-import * as Fx from '@/Fx/Fx.js'
-
-export const empty = Stream<never, never, never>((sink, scheduler, context) =>
-  Fx.asksEnv((env) => scheduler.asap(sink.end, env, context)),
-)