@typed/fx 0.0.4 → 0.0.6

package/src/Stream/scheduled.test.ts

@@ -3,7 +3,7 @@ import { deepStrictEqual } from 'assert'
 import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { collectAll } from './_internal.test.js'
-import { scheduled } from './scheduled.js'
+import { at, scheduled } from './scheduled.js'
 
 import * as Fx from '@/Fx/index.js'
 import * as Schedule from '@/Schedule/index.js'
@@ -31,4 +31,12 @@ testSuite(import.meta.url, () => {
       )
     })
   })
+
+  describe(at.name, () => {
+    it('runs Fx at a given time', async () => {
+      const value = Math.random()
+
+      deepStrictEqual(await collectAll(at(Delay(5))(value)), [value])
+    })
+  })
 })

package/src/Stream/scheduled.ts

@@ -1,21 +1,55 @@
+import { pipe } from 'hkt-ts'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
 import { Stream } from './Stream.js'
 
 import { Env } from '@/Env/Env.js'
-import * as Fx from '@/Fx/Fx.js'
-import { span } from '@/Fx/logging.js'
-import { Schedule } from '@/Schedule/Schedule.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import * as Fx from '@/Fx/index.js'
+import * as Schedule from '@/Schedule/Schedule.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+import { Delay } from '@/Time/index.js'
+import { FiberId } from '@/index.js'
 
-export function scheduled(schedule: Schedule) {
+export function scheduled(schedule: Schedule.Schedule, __trace?: string) {
   return <R, E, A>(fx: Fx.Fx<R, E, A>): Stream<R, E, A> =>
-    Stream((sink, scheduler, context) =>
-      Fx.asksEnv((env: Env<R>) =>
-        scheduler.schedule(
-          Fx.matchCause(sink.error, sink.event)(fx),
-          env,
-          schedule,
-          context,
-          span('Stream.scheduled'),
+    Stream(<E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) =>
+      pipe(
+        Fx.asksEnv(
+          (env: Env<R>) =>
+            scheduler.schedule(
+              Fx.matchCause(sink.error, sink.event, __trace)(fx),
+              env,
+              schedule,
+              context,
+              () => sink.end,
+            ),
+          __trace,
         ),
       ),
     )
 }
+
+export function at(delay: Delay, __trace?: string) {
+  return <A>(value: A): Stream<never, never, A> =>
+    scheduled(Schedule.delayed(delay), __trace)(Fx.now(value))
+}
+
+export function repeated(period: Delay, __trace?: string) {
+  return <A>(value: A): Stream<never, never, A> =>
+    scheduled(Schedule.periodic(period), __trace)(Fx.now(value))
+}
+
+export const exponential = (delay: Delay, __trace?: string) =>
+  scheduled(Schedule.exponential(delay), __trace)
+
+export const forever = scheduled(Schedule.forever, 'Scheduled.forever')
+
+export const recurring = (amount: NonNegativeInteger, __trace?: string) =>
+  scheduled(Schedule.recurring(amount), __trace)
+
+export const retries = (amount: NonNegativeInteger, __trace?: string) =>
+  scheduled(Schedule.retries(amount), __trace)
+
+export const spaced = (delay: Delay, __trace?: string) => scheduled(Schedule.spaced(delay), __trace)

package/src/Stream/setFiberRefLocally.ts

@@ -0,0 +1,44 @@
+import { pipe } from 'hkt-ts'
+
+import { Stream } from './Stream.js'
+
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { FiberRef } from '@/FiberRef/FiberRef.js'
+import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
+import { flatMap, fromLazy } from '@/Fx/Fx.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+
+export function setFiberRefLocally<R, E, A>(fiberRef: FiberRef<R, E, A>, value: () => A) {
+  return <R2, E2, A2>(fx: Stream<R2, E2, A2>) => new SetFiberRefLocallyStream(fx, fiberRef, value)
+}
+
+export class SetFiberRefLocallyStream<R, E, A, R2, E2, A2> implements Stream<R2, E2, A2> {
+  constructor(
+    readonly stream: Stream<R2, E2, A2>,
+    readonly fiberRef: FiberRef<R, E, A>,
+    readonly value: () => A,
+  ) {}
+
+  fork<E3>(sink: Sink<E2, A2, E3>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) {
+    return pipe(
+      fromLazy(() => FiberRefs.setFiberRefLocally(this.fiberRef, this.value())(context.fiberRefs)),
+      flatMap(() =>
+        this.stream.fork(
+          {
+            ...sink,
+            end: pipe(
+              sink.end,
+              flatMap(() =>
+                fromLazy(() => FiberRefs.popLocalFiberRef(this.fiberRef)(context.fiberRefs)),
+              ),
+            ),
+          },
+          scheduler,
+          context,
+        ),
+      ),
+    )
+  }
+}

package/src/Stream/switchMap.test.ts

@@ -0,0 +1,43 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { collectAll } from './_internal.test.js'
+import { now } from './fromFx.js'
+import { merge } from './merge.js'
+import { at } from './scheduled.js'
+import { switchMap } from './switchMap.js'
+
+import { Delay } from '@/Time/index.js'
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(switchMap.name, () => {
+    const value = Math.random()
+    const stream = pipe(
+      now(value),
+      switchMap((a) => now(a + 1)),
+    )
+
+    it('is collectable', async () => {
+      const events = await collectAll(stream)
+      deepStrictEqual(events, [value + 1])
+    })
+
+    it('is collectable with multiple subscribers', async () => {
+      const events = await Promise.all([collectAll(stream), collectAll(stream)])
+      deepStrictEqual(events, [[value + 1], [value + 1]])
+    })
+
+    it('cancels the previous stream', async () => {
+      const stream = pipe(
+        at(Delay(0))(1),
+        merge(at(Delay(50))(5)),
+        switchMap((a) => pipe(now(a), merge(at(Delay(100))(a + 1)))),
+      )
+
+      const events = await collectAll(stream)
+      deepStrictEqual(events, [1, 5, 6])
+    })
+  })
+})

package/src/Stream/switchMap.ts

@@ -0,0 +1,159 @@
+import { flow, pipe } from 'hkt-ts'
+import { isRight } from 'hkt-ts/Either'
+import { isJust } from 'hkt-ts/Maybe'
+
+import { Stream } from './Stream.js'
+import { MapStream } from './map.js'
+
+import { Cause } from '@/Cause/index.js'
+import { Disposable, Settable, settable } from '@/Disposable/Disposable.js'
+import { Env } from '@/Env/Env.js'
+import { Fiber } from '@/Fiber/Fiber.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { Live } from '@/FiberId/FiberId.js'
+import * as FiberRefs from '@/FiberRefs/index.js'
+import * as Fx from '@/Fx/index.js'
+import { access, lazy, unit } from '@/Fx/index.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Lock } from '@/Semaphore/Semaphore.js'
+import * as Sink from '@/Sink/Sink.js'
+import { None, and } from '@/Supervisor/Supervisor.js'
+
+export function switchMap<A, R2, E2, B>(
+  f: (a: A) => Stream<R2, E2, B>,
+  __trace?: string,
+): <R, E>(stream: Stream<R, E, A>) => Stream<R | R2, E | E2, B> {
+  return (stream) => SwitchMapStream.make(stream, f, __trace)
+}
+
+export function switchLatest<R, E, R2, E2, A>(
+  stream: Stream<R, E, Stream<R2, E2, A>>,
+  __trace?: string,
+): Stream<R | R2, E | E2, A> {
+  return switchMap((a: Stream<R2, E2, A>) => a, __trace)(stream)
+}
+
+export class SwitchMapStream<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2, B> {
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: (a: A) => Stream<R2, E2, B>,
+    readonly __trace?: string,
+  ) {}
+
+  fork<E3>(sink: Sink.Sink<E | E2, B, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
+    const { stream, f } = this
+
+    return access((env: Env<R | R2>) =>
+      stream.fork(
+        new SwitchMapSink(sink, scheduler, context, f, env, this.__trace),
+        scheduler,
+        context,
+      ),
+    )
+  }
+
+  static make<R, E, A, R2, E2, B>(
+    stream: Stream<R, E, A>,
+    f: (a: A) => Stream<R2, E2, B>,
+    __trace?: string,
+  ): Stream<R | R2, E | E2, B> {
+    if (stream instanceof MapStream) {
+      return SwitchMapStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    return new SwitchMapStream(stream, f, __trace)
+  }
+}
+
+class SwitchMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, A, E3> {
+  protected _ended = false
+  protected _fibers: Array<Fiber<E3, any>> = []
+  protected _lock = new Lock()
+
+  protected _supervisor = None.extend({
+    onEnd: () => (fiber, exit) => {
+      const parentContext = fiber.context.parent
+
+      // Merge FiberRefs upon successful completion
+      if (isRight(exit) && isJust(parentContext)) {
+        FiberRefs.join(parentContext.value.fiberRefs, fiber.context.fiberRefs)
+      }
+    },
+  })
+
+  constructor(
+    readonly sink: Sink.Sink<E | E2, B, E3>,
+    readonly scheduler: Scheduler,
+    readonly context: FiberContext<Live>,
+    readonly f: (a: A) => Stream<R2, E2, B>,
+    readonly env: Env<R | R2>,
+    readonly __trace?: string,
+  ) {}
+
+  event = (a: A): Fx.IO<E3, unknown> =>
+    Fx.lazy(() => {
+      const forked = this.context.fork({
+        supervisor: and(this._supervisor)(this.context.supervisor),
+      })
+
+      const cleanup: Fx.Of<unknown> = Fx.zipAll(this._fibers.map((f) => f.interruptAs(forked.id)))
+      const disposable = settable()
+      const sink = this.innerSink(disposable)
+
+      return pipe(
+        cleanup, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Fx.flatMap(() => this.f(a).fork(Sink.addTrace(sink, this.__trace), this.scheduler, forked)),
+        Fx.tapLazy((fiber) => {
+          this._fibers.push(fiber)
+
+          disposable.add(
+            Disposable(() => {
+              this._fibers.splice(this._fibers.indexOf(fiber), 1)
+            }),
+          )
+        }),
+        Fx.flatMap((fiber) =>
+          pipe(
+            fiber,
+            Fx.join,
+            Fx.tapLazy(() => disposable.dispose()),
+          ),
+        ),
+        (x) => x,
+        Fx.provide(this.env),
+      )
+    })
+
+  error = (cause: Cause<E | E2>) => {
+    return lazy(() => {
+      this._ended = true
+
+      return this.sink.error(cause)
+    })
+  }
+
+  end = lazy(() => {
+    this._ended = true
+
+    return this.endIfCompleted()
+  })
+
+  protected endIfCompleted() {
+    if (this._ended && this._fibers.length === 0) {
+      return this.sink.end
+    }
+
+    return unit
+  }
+
+  protected innerSink(disposable: Settable): Sink.Sink<E | E2, B, E3> {
+    return {
+      event: this.sink.event,
+      error: this.error,
+      end: lazy(() => {
+        disposable.dispose()
+        return this.endIfCompleted()
+      }),
+    }
+  }
+}

package/src/Stream/tap.ts

@@ -3,10 +3,10 @@ import { pipe } from 'hkt-ts/function'
 import { Stream } from './Stream.js'
 import { flatMapFx } from './flatMapFx.js'
 
-import { Fx, map } from '@/Fx/Fx.js'
+import { Fx, fromLazy, map } from '@/Fx/Fx.js'
 
 export const tap =
-  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) =>
+  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, __trace?: string) =>
   <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, A> =>
     pipe(
       stream,
@@ -16,6 +16,9 @@ export const tap =
             f(a),
             map(() => a),
           ),
-        'Stream.tap',
+        __trace,
       ),
     )
+
+export const tapLazy = <A, B>(f: (a: A) => B, __trace?: string) =>
+  tap((a: A) => fromLazy(() => f(a)), __trace)

package/src/Timeline/index.ts

@@ -51,6 +51,7 @@ class TimelineImpl<A> implements Timeline<A> {
 
   readonly add = (time: UnixTime, a: A): Disposable => {
     insertByTime(time, a, this.timeSlots)
+
     this.onUpdated?.()
 
     return Disposable(() => this.remove(time, a))

package/cjs/Effect/Effect.d.ts

@@ -1,199 +0,0 @@
-import * as F from 'hkt-ts/function';
-import * as C from "../Cause/index.js";
-import { Cause } from "../Cause/index.js";
-import { Exit } from "../Exit/Exit.js";
-export declare abstract class EffectBrand<R, E, A> {
-    readonly __EFFECT__: {
-        readonly _R: () => R;
-        readonly _E: () => E;
-        readonly _A: () => A;
-    };
-}
-export declare abstract class Instr<out I, out R, out E, out A> extends EffectBrand<R, E, A> {
-    readonly input: I;
-    readonly __trace?: string | undefined;
-    static tag: string;
-    abstract readonly tag: string;
-    constructor(input: I, __trace?: string | undefined);
-    [Symbol.iterator](): Generator<this, A, any>;
-}
-export declare const instr: <Tag extends string>(tag: Tag) => {
-    new <I, R, E, A>(input: I, __trace?: string): {
-        readonly tag: Tag;
-        readonly input: I;
-        readonly __trace?: string;
-        [Symbol.iterator](): Generator<any, A, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R;
-            readonly _E: () => E;
-            readonly _A: () => A;
-        };
-    };
-    tag: Tag;
-};
-export declare type YieldOf<T> = T extends EffectBrand<infer _R, infer _E, infer _A> ? _R : never;
-export declare type ErrorsOf<T> = T extends EffectBrand<infer _R, infer _E, infer _A> ? _E : never;
-export declare type OutputOf<T> = T extends EffectBrand<infer _R, infer _E, infer _A> ? _A : never;
-export declare type Effect<R, E, A> = Now<A> | FromLazy<A> | FromCause<E> | LazyEffect<R, E, A> | MapEffect<R, E, any, A> | FlatMapEffect<R, E, any, R, E, A> | OrElseEffect<R, any, A, R, E, A> | EnsuringEffect<R, any, any, R, E, A> | YieldNow | YieldEffect<R>;
-declare const Now_base: {
-    new <I, R, E, A_1>(input: I, __trace?: string | undefined): {
-        readonly tag: "Now";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A_1, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R;
-            readonly _E: () => E;
-            readonly _A: () => A_1;
-        };
-    };
-    tag: "Now";
-};
-export declare class Now<A> extends Now_base<A, never, never, A> {
-}
-declare const FromLazy_base: {
-    new <I, R, E, A_1>(input: I, __trace?: string | undefined): {
-        readonly tag: "FromLazy";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A_1, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R;
-            readonly _E: () => E;
-            readonly _A: () => A_1;
-        };
-    };
-    tag: "FromLazy";
-};
-export declare class FromLazy<A> extends FromLazy_base<F.Lazy<A>, never, never, A> {
-}
-declare const FromCause_base: {
-    new <I, R, E_1, A>(input: I, __trace?: string | undefined): {
-        readonly tag: "FromCause";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R;
-            readonly _E: () => E_1;
-            readonly _A: () => A;
-        };
-    };
-    tag: "FromCause";
-};
-export declare class FromCause<E> extends FromCause_base<C.Cause<E>, never, E, never> {
-}
-declare const LazyEffect_base: {
-    new <I, R_1, E_1, A_1>(input: I, __trace?: string | undefined): {
-        readonly tag: "LazyEffect";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A_1, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R_1;
-            readonly _E: () => E_1;
-            readonly _A: () => A_1;
-        };
-    };
-    tag: "LazyEffect";
-};
-export declare class LazyEffect<R, E, A> extends LazyEffect_base<F.Lazy<Effect<R, E, A>>, R, E, A> {
-}
-declare const MapEffect_base: {
-    new <I, R_1, E_1, A_1>(input: I, __trace?: string | undefined): {
-        readonly tag: "MapEffect";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A_1, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R_1;
-            readonly _E: () => E_1;
-            readonly _A: () => A_1;
-        };
-    };
-    tag: "MapEffect";
-};
-export declare class MapEffect<R, E, A, B> extends MapEffect_base<readonly [Effect<R, E, A>, (a: A) => B], R, E, B> {
-}
-declare const FlatMapEffect_base: {
-    new <I, R_1, E_1, A_1>(input: I, __trace?: string | undefined): {
-        readonly tag: "FlatMapEffect";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A_1, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R_1;
-            readonly _E: () => E_1;
-            readonly _A: () => A_1;
-        };
-    };
-    tag: "FlatMapEffect";
-};
-export declare class FlatMapEffect<R, E, A, R2, E2, B> extends FlatMapEffect_base<readonly [Effect<R, E, A>, (a: A) => Effect<R2, E2, B>], R | R2, E | E2, B> {
-}
-declare const OrElseEffect_base: {
-    new <I, R_1, E_1, A_1>(input: I, __trace?: string | undefined): {
-        readonly tag: "OrElseEffect";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A_1, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R_1;
-            readonly _E: () => E_1;
-            readonly _A: () => A_1;
-        };
-    };
-    tag: "OrElseEffect";
-};
-export declare class OrElseEffect<R, E, A, R2, E2, B> extends OrElseEffect_base<readonly [Effect<R, E, A>, (cause: Cause<E>) => Effect<R2, E2, B>], R | R2, E2, A | B> {
-}
-declare const EnsuringEffect_base: {
-    new <I, R_1, E_1, A_1>(input: I, __trace?: string | undefined): {
-        readonly tag: "Ensuring";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A_1, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R_1;
-            readonly _E: () => E_1;
-            readonly _A: () => A_1;
-        };
-    };
-    tag: "Ensuring";
-};
-export declare class EnsuringEffect<R, E, A, R2, E2, B> extends EnsuringEffect_base<readonly [Effect<R, E, A>, (cause: Exit<E, A>) => Effect<R2, E2, B>], R | R2, E2, B> {
-}
-declare const YieldNow_base: {
-    new <I, R, E, A>(input: I, __trace?: string | undefined): {
-        readonly tag: "YieldNow";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R;
-            readonly _E: () => E;
-            readonly _A: () => A;
-        };
-    };
-    tag: "YieldNow";
-};
-export declare class YieldNow extends YieldNow_base<never, never, never, void> {
-}
-declare const YieldEffect_base: {
-    new <I, R_1, E, A>(input: I, __trace?: string | undefined): {
-        readonly tag: "YieldEffect";
-        readonly input: I;
-        readonly __trace?: string | undefined;
-        [Symbol.iterator](): Generator<any, A, any>;
-        readonly __EFFECT__: {
-            readonly _R: () => R_1;
-            readonly _E: () => E;
-            readonly _A: () => A;
-        };
-    };
-    tag: "YieldEffect";
-};
-export declare class YieldEffect<R> extends YieldEffect_base<R, R | YieldOf<R>, ErrorsOf<R>, OutputOf<R>> {
-}
-export {};
-//# sourceMappingURL=Effect.d.ts.map

package/cjs/Effect/Effect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Effect.d.ts","sourceRoot":"","sources":["../../src/Effect/Effect.ts"],"names":[],"mappings":"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"}

package/cjs/Effect/Effect.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.YieldEffect = exports.YieldNow = exports.EnsuringEffect = exports.OrElseEffect = exports.FlatMapEffect = exports.MapEffect = exports.LazyEffect = exports.FromCause = exports.FromLazy = exports.Now = exports.instr = exports.Instr = exports.EffectBrand = void 0;
-// TODO: Track yields as a Tuple?
-// TODO: Track Return HKTs?
-class EffectBrand {
-    __EFFECT__;
-}
-exports.EffectBrand = EffectBrand;
-class Instr extends EffectBrand {
-    input;
-    __trace;
-    static tag;
-    constructor(input, __trace) {
-        super();
-        this.input = input;
-        this.__trace = __trace;
-    }
-    *[Symbol.iterator]() {
-        return yield this;
-    }
-}
-exports.Instr = Instr;
-const instr = (tag) => class Instruction extends Instr {
-    static tag = tag;
-    tag = tag;
-};
-exports.instr = instr;
-class Now extends (0, exports.instr)('Now') {
-}
-exports.Now = Now;
-class FromLazy extends (0, exports.instr)('FromLazy') {
-}
-exports.FromLazy = FromLazy;
-class FromCause extends (0, exports.instr)('FromCause') {
-}
-exports.FromCause = FromCause;
-class LazyEffect extends (0, exports.instr)('LazyEffect') {
-}
-exports.LazyEffect = LazyEffect;
-class MapEffect extends (0, exports.instr)('MapEffect') {
-}
-exports.MapEffect = MapEffect;
-class FlatMapEffect extends (0, exports.instr)('FlatMapEffect') {
-}
-exports.FlatMapEffect = FlatMapEffect;
-class OrElseEffect extends (0, exports.instr)('OrElseEffect') {
-}
-exports.OrElseEffect = OrElseEffect;
-class EnsuringEffect extends (0, exports.instr)('Ensuring') {
-}
-exports.EnsuringEffect = EnsuringEffect;
-class YieldNow extends (0, exports.instr)('YieldNow') {
-}
-exports.YieldNow = YieldNow;
-class YieldEffect extends (0, exports.instr)('YieldEffect') {
-}
-exports.YieldEffect = YieldEffect;
-// TODO: ProvideHandler + Handler
-// TODO: GetHandlers - Use HKT to track return values?
-// TODO: StackMap + References
-// TODO: Interrupts
-// TODO: Tracing
-// TODO: Supervision
-// TODO: Multiple Resumes
-//# sourceMappingURL=Effect.js.map

package/cjs/Effect/Effect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Effect.js","sourceRoot":"","sources":["../../src/Effect/Effect.ts"],"names":[],"mappings":";;;AAMA,iCAAiC;AACjC,2BAA2B;AAE3B,MAAsB,WAAW;IACtB,UAAU,CAIlB;CACF;AAND,kCAMC;AAED,MAAsB,KAAkC,SAAQ,WAAoB;IAI7D;IAAmB;IAHxC,MAAM,CAAC,GAAG,CAAQ;IAGlB,YAAqB,KAAQ,EAAW,OAAgB;QACtD,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAG;QAAW,YAAO,GAAP,OAAO,CAAS;IAExD,CAAC;IAED,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;QAChB,OAAO,MAAM,IAAI,CAAA;IACnB,CAAC;CACF;AAXD,sBAWC;AAEM,MAAM,KAAK,GAAG,CAAqB,GAAQ,EAAE,EAAE,CACpD,MAAM,WAAwB,SAAQ,KAAiB;IACrD,MAAM,CAAC,GAAG,GAAQ,GAAG,CAAA;IACZ,GAAG,GAAQ,GAAG,CAAA;CACxB,CAAA;AAJU,QAAA,KAAK,SAIf;AAuBH,MAAa,GAAO,SAAQ,IAAA,aAAK,EAAC,KAAK,CAAqB;CAAG;AAA/D,kBAA+D;AAE/D,MAAa,QAAY,SAAQ,IAAA,aAAK,EAAC,UAAU,CAA6B;CAAG;AAAjF,4BAAiF;AAEjF,MAAa,SAAa,SAAQ,IAAA,aAAK,EAAC,WAAW,CAA8B;CAAG;AAApF,8BAAoF;AAEpF,MAAa,UAAoB,SAAQ,IAAA,aAAK,EAAC,YAAY,CAAmC;CAAG;AAAjG,gCAAiG;AAEjG,MAAa,SAAsB,SAAQ,IAAA,aAAK,EAAC,WAAW,CAK3D;CAAG;AALJ,8BAKI;AAEJ,MAAa,aAAkC,SAAQ,IAAA,aAAK,EAAC,eAAe,CAK3E;CAAG;AALJ,sCAKI;AAEJ,MAAa,YAAiC,SAAQ,IAAA,aAAK,EAAC,cAAc,CAKzE;CAAG;AALJ,oCAKI;AAEJ,MAAa,cAAmC,SAAQ,IAAA,aAAK,EAAC,UAAU,CAKvE;CAAG;AALJ,wCAKI;AAEJ,MAAa,QAAS,SAAQ,IAAA,aAAK,EAAC,UAAU,CAA4B;CAAG;AAA7E,4BAA6E;AAE7E,MAAa,WAAe,SAAQ,IAAA,aAAK,EAAC,aAAa,CAKtD;CAAG;AALJ,kCAKI;AAEJ,iCAAiC;AACjC,sDAAsD;AACtD,8BAA8B;AAC9B,mBAAmB;AACnB,gBAAgB;AAChB,oBAAoB;AACpB,yBAAyB"}