@typed/fx 0.0.4 → 0.0.8

package/src/Stream/flatMap.ts

@@ -1,69 +1,91 @@
 import { flow, pipe } from 'hkt-ts'
 
 import { Stream } from './Stream.js'
-import { MapStream } from './map.js'
+import { MapStream } from './bimap.js'
 
-import { AtomicCounter, decrement } from '@/Atomic/AtomicCounter.js'
+import { AtomicCounter, decrement, increment } from '@/Atomic/AtomicCounter.js'
 import { Cause } from '@/Cause/index.js'
 import { Env } from '@/Env/Env.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { Live } from '@/FiberId/FiberId.js'
 import * as Fx from '@/Fx/index.js'
-import { lazy, span, unit } from '@/Fx/index.js'
+import { access, lazy, unit } from '@/Fx/index.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
+import * as Sink from '@/Sink/Sink.js'
+import * as Supervisor from '@/Supervisor/index.js'
 
 export function flatMap<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) => FlatMapStream.make(stream, f)
+  return (stream) => FlatMapStream.make(stream, f, __trace)
+}
+
+export function join<R, E, R2, E2, A>(
+  stream: Stream<R, E, Stream<R2, E2, A>>,
+  __trace?: string,
+): Stream<R | R2, E | E2, A> {
+  return flatMap((a: Stream<R2, E2, A>) => a, __trace)(stream)
 }
 
 export class FlatMapStream<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>) {}
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: (a: A) => Stream<R2, E2, B>,
+    readonly __trace?: string,
+  ) {}
 
-  fork<E3>(sink: Sink<E | E2, B, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
+  fork<E3>(sink: Sink.Sink<E | E2, B, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
     const { stream, f } = this
 
-    return pipe(
-      Fx.getEnv<R | R2>(),
-      Fx.flatMap((env) =>
-        stream.fork(new FlatMapSink(sink, scheduler, context, f, env), scheduler, context),
+    return access((env: Env<R | R2>) =>
+      stream.fork(
+        new FlatMapSink(sink, scheduler, context, f, env, this.__trace),
+        scheduler,
+        context,
       ),
-      span('Stream.flatMap'),
     )
   }
 
   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 FlatMapStream.make(stream.stream, flow(stream.f, f))
+      return FlatMapStream.make(stream.stream, flow(stream.f, f), __trace)
     }
 
-    return new FlatMapStream(stream, f)
+    return new FlatMapStream(stream, f, __trace)
   }
 }
 
-class FlatMapSink<R, E, A, R2, E2, B, E3> implements Sink<E | E2, A, E3> {
+class FlatMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, A, E3> {
   protected _running = AtomicCounter()
   protected _ended = false
 
   constructor(
-    readonly sink: Sink<E | E2, B, E3>,
+    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) => {
-    return pipe(
-      this.f(a).fork(this.innerSink(), this.scheduler, this.context.fork()),
-      Fx.provide(this.env),
-    )
-  }
+  event = (a: A) =>
+    Fx.lazy(() => {
+      const forked = this.context.fork({
+        supervisor: Supervisor.and(Supervisor.inheritFiberRefs)(this.context.supervisor),
+      })
+
+      increment(this._running)
+
+      return pipe(
+        this.f(a).fork(Sink.addTrace(this.innerSink(), this.__trace), this.scheduler, forked),
+        Fx.provide(this.env),
+      )
+    })
 
   error = (cause: Cause<E | E2>) => {
     return lazy(() => {
@@ -82,14 +104,14 @@ class FlatMapSink<R, E, A, R2, E2, B, E3> implements Sink<E | E2, A, E3> {
   protected endIfCompleted() {
     return lazy(() => {
       if (this._ended && this._running.get() === 0) {
-        this.sink.end
+        return this.sink.end
       }
 
       return unit
     })
   }
 
-  protected innerSink(): Sink<E | E2, B, E3> {
+  protected innerSink(): Sink.Sink<E | E2, B, E3> {
     return {
       event: this.sink.event,
       error: this.error,

package/src/Stream/flatMapConcurrently.test.ts

@@ -0,0 +1,77 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { collectAll } from './_internal.test.js'
+import { flatMapConcurrently } from './flatMapConcurrently.js'
+import { fromCallback } from './fromCallback.js'
+import { merge } from './merge.js'
+
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(flatMapConcurrently.name, () => {
+    const value = 42
+    const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+    const stream = (level: number) =>
+      pipe(
+        fromCallback<never, number>(async ({ event, end }) => {
+          event(value)
+          event(value + 5)
+          event(value + 10)
+          end()
+        }),
+        merge(
+          fromCallback<never, number>(async ({ event, end }) => {
+            event(value + 15)
+            event(value + 20)
+            end()
+          }),
+        ),
+        flatMapConcurrently(
+          (a) =>
+            fromCallback<never, number>(async ({ event, end }) => {
+              event(a + 1)
+              await sleep(10)
+              event(a + 2)
+              end()
+            }),
+          NonNegativeInteger(level),
+        ),
+      )
+
+    it('it should control concurrency', async () => {
+      const noConcurrency = await collectAll(stream(Infinity))
+
+      deepStrictEqual(noConcurrency, [
+        value + 1,
+        value + 5 + 1,
+        value + 10 + 1,
+        value + 15 + 1,
+        value + 20 + 1,
+        value + 2,
+        value + 5 + 2,
+        value + 10 + 2,
+        value + 15 + 2,
+        value + 20 + 2,
+      ])
+
+      const withConcurrency = await collectAll(stream(1))
+
+      deepStrictEqual(withConcurrency, [
+        value + 1,
+        value + 2,
+        value + 5 + 1,
+        value + 5 + 2,
+        value + 10 + 1,
+        value + 10 + 2,
+        value + 15 + 1,
+        value + 15 + 2,
+        value + 20 + 1,
+        value + 20 + 2,
+      ])
+    })
+  })
+})

package/src/Stream/flatMapConcurrently.ts

@@ -0,0 +1,34 @@
+import { flow, pipe } from 'hkt-ts/function'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { Stream } from './Stream.js'
+import { acquirePermit } from './acquirePermit.js'
+import { flatMap } from './flatMap.js'
+import { lazy } from './lazy.js'
+
+import { Semaphore } from '@/Semaphore/index.js'
+
+export function flatMapConcurrently<A, R2, E2, B>(
+  f: (a: A) => Stream<R2, E2, B>,
+  concurrencyLevel: NonNegativeInteger,
+  __trace?: string,
+) {
+  return <R, E>(stream: Stream<R, E, A>) =>
+    lazy(() => {
+      const semaphore = new Semaphore(concurrencyLevel)
+
+      return pipe(stream, flatMap(flow(f, acquirePermit(semaphore)), __trace))
+    })
+}
+
+export function mergeConcurrently(concurrencyLevel: NonNegativeInteger, __trace?: string) {
+  return <R, E, R2, E2, A>(stream: Stream<R, E, Stream<R2, E2, A>>) =>
+    pipe(
+      stream,
+      flatMapConcurrently((a) => a, concurrencyLevel, __trace),
+    )
+}
+
+export function concatMap<A, R2, E2, B>(f: (a: A) => Stream<R2, E2, B>, __trace?: string) {
+  return flow(flatMapConcurrently(f, NonNegativeInteger(1), __trace))
+}

package/src/Stream/flatMapFx.ts

@@ -1,12 +1,45 @@
-import { flow, pipe } from 'hkt-ts/function'
+import { pipe } from 'hkt-ts/function'
+import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { Stream } from './Stream.js'
 import { flatMap } from './flatMap.js'
-import { makeFromFx } from './fromFx.js'
+import { flatMapConcurrently } from './flatMapConcurrently.js'
+import { fromFx } from './fromFx.js'
 
 import { Fx } from '@/Fx/Fx.js'
 
-export function flatMapFx<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, span = 'Stream.flatMapFx') {
+export function flatMapFx<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, __trace?: string) {
   return <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, B> =>
-    pipe(stream, flatMap(flow(f, makeFromFx(span))))
+    pipe(
+      stream,
+      flatMap((a) => fromFx(f(a), __trace), __trace),
+    )
+}
+
+export function joinFx<R, E, A>(stream: Stream<R, E, Fx<R, E, A>>, __trace?: string) {
+  return pipe(
+    stream,
+    flatMapFx((x) => x, __trace),
+  )
+}
+
+export function flatMapFxConcurrently<A, R2, E2, B>(
+  f: (a: A) => Fx<R2, E2, B>,
+  concurrencyLevel: NonNegativeInteger,
+  __trace?: string,
+) {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, B> =>
+    pipe(
+      stream,
+      flatMapConcurrently((a) => fromFx(f(a), __trace), concurrencyLevel, __trace),
+    )
+}
+
+export function mergeFxConcurrently(concurrencyLevel: NonNegativeInteger, __trace?: string) {
+  return <R, E, R2, E2, A>(stream: Stream<R, E, Fx<R2, E2, A>>) => {
+    return pipe(
+      stream,
+      flatMapFxConcurrently((x) => x, concurrencyLevel, __trace),
+    )
+  }
 }

package/src/Stream/foldMap.ts

@@ -0,0 +1,88 @@
+import { Maybe, flow, pipe } from 'hkt-ts'
+import * as Endo from 'hkt-ts/Endomorphism'
+import { Identity } from 'hkt-ts/Typeclass/Identity'
+import * as B from 'hkt-ts/boolean'
+
+import { Stream } from './Stream.js'
+import { FilterMapStream, MapStream } from './bimap.js'
+import { observe } from './drain.js'
+import { FromFxStream } from './fromFx.js'
+
+import * as Fx from '@/Fx/index.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+
+export const filterFoldMap = <A>(I: Identity<A>) => {
+  const foldMap_ =
+    <B>(f: (b: B) => Maybe.Maybe<A>, __trace?: string) =>
+    <R, E>(stream: Stream<R, E, B>): Fx.Fx<R | Scheduler, E, A> => {
+      if (stream instanceof FromFxStream) {
+        return pipe(
+          stream.fx,
+          Fx.map(
+            flow(
+              f,
+              Maybe.match(
+                () => I.id,
+                (a) => I.concat(I.id, a),
+              ),
+            ),
+          ),
+        )
+      }
+
+      if (stream instanceof MapStream) {
+        return foldMap_(flow(stream.f, f), __trace)(stream.stream)
+      }
+
+      if (stream instanceof FilterMapStream) {
+        return foldMap_(flow(stream.f, Maybe.flatMap(f)), __trace)(stream.stream)
+      }
+
+      return filterFoldMapStream(I, f, stream, __trace)
+    }
+
+  return foldMap_
+}
+
+export const foldMap =
+  <A>(I: Identity<A>) =>
+  <B>(f: (b: B) => A) =>
+    filterFoldMap(I)(flow(f, Maybe.Just))
+
+const filterFoldMapStream = <A, B, R, E>(
+  I: Identity<A>,
+  f: (b: B) => Maybe.Maybe<A>,
+  stream: Stream<R, E, B>,
+  __trace?: string,
+) =>
+  Fx.lazy(() => {
+    let acc = I.id
+
+    return pipe(
+      stream,
+      observe((b) =>
+        Fx.fromLazy(() => {
+          const maybe = f(b)
+
+          if (Maybe.isJust(maybe)) {
+            acc = I.concat(acc, maybe.value)
+          }
+        }),
+      ),
+      Fx.flatMap(Fx.join),
+      Fx.map(() => acc, __trace),
+    )
+  })
+
+export const reduce = <A, B>(
+  f: (a: A, b: B) => A,
+  seed: A,
+): (<R, E>(stream: Stream<R, E, B>) => Fx.Fx<Scheduler | R, E, A>) => {
+  return flow(
+    foldMap(Endo.makeIdentity<A>())((a: B) => (b: A) => f(b, a)),
+    Fx.flap(seed),
+  )
+}
+
+export const every = foldMap(B.All)
+export const some = foldMap(B.Any)

package/src/Stream/fromArray.ts

@@ -0,0 +1,8 @@
+import { fromCallback } from './fromCallback.js'
+
+export function fromArray<A>(array: ReadonlyArray<A>) {
+  return fromCallback<never, A>(async ({ event, end }) => {
+    await Promise.all(array.map(event))
+    await end()
+  })
+}

package/src/Stream/fromCallback.test.ts

@@ -1,13 +1,8 @@
 import { deepStrictEqual } from 'assert'
 
-import { pipe } from 'hkt-ts'
-
-import { collect } from './drain.js'
+import { collectAll } from './_internal.test.js'
 import { fromCallback } from './fromCallback.js'
 
-import * as Fx from '@/Fx/index.js'
-import { RootScheduler } from '@/Scheduler/RootScheduler.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
 import { testSuite } from '@/_internal/suite.js'
 
 testSuite(import.meta.url, () => {
@@ -20,16 +15,8 @@ testSuite(import.meta.url, () => {
       await end()
     })
 
-    it('should be collectable', async () => {
-      await pipe(
-        Fx.Fx(function* () {
-          const events: readonly number[] = yield* collect(stream)
-
-          deepStrictEqual(events, [value, value + 1, value + 2])
-        }),
-        Fx.provideService(Scheduler, RootScheduler()),
-        Fx.runMain,
-      )
+    it('is collectable', async () => {
+      deepStrictEqual(await collectAll(stream), [value, value + 1, value + 2])
     })
   })
 })

package/src/Stream/fromCallback.ts

@@ -1,19 +1,18 @@
 import { flow, pipe } from 'hkt-ts'
+import { Left, Right } from 'hkt-ts/Either'
 
 import { Stream } from './Stream.js'
 
 import { Cause } from '@/Cause/index.js'
-import { Fiber, Synthetic } from '@/Fiber/Fiber.js'
+import { Fiber } from '@/Fiber/Fiber.js'
+import { fromScope } from '@/Fiber/fromScope.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { FiberId } from '@/FiberId/FiberId.js'
-import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
 import { Finalizer } from '@/Finalizer/Finalizer.js'
 import * as Fx from '@/Fx/index.js'
 import { Runtime } from '@/Runtime/Runtime.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { closeOrWait, wait } from '@/Scope/Closeable.js'
-import { Sink } from '@/Sink/Sink.js'
-import { Exit } from '@/index.js'
+import { Sink, addTrace } from '@/Sink/Sink.js'
 
 export interface CallbackSink<E, A> {
   readonly event: (a: A) => Promise<any>
@@ -21,45 +20,65 @@ export interface CallbackSink<E, A> {
   readonly end: () => Promise<any>
 }
 
-export function fromCallback<E, A>(
-  f: <E2>(sink: CallbackSink<E | E2, A>) => Finalizer | void | Promise<Finalizer | void>,
+export function fromCallback<E = never, A = unknown>(
+  f: (sink: CallbackSink<E, A>) => Finalizer | void | Promise<Finalizer | void>,
+  __trace?: string,
 ): Stream<never, E, A> {
-  return new FromCallback<E, A>(f)
+  return new FromCallback<E, A>(f, __trace)
 }
 
 export class FromCallback<E, A> implements Stream<never, E, A> {
   constructor(
-    readonly f: <E2>(sink: CallbackSink<E | E2, A>) => Finalizer | void | Promise<Finalizer | void>,
+    readonly f: (sink: CallbackSink<E, A>) => Finalizer | void | Promise<Finalizer | void>,
+    readonly __trace?: string,
   ) {}
 
   fork = <E2>(
     sink: Sink<E, A, E2>,
     _: Scheduler,
     context: FiberContext<FiberId.Live>,
-  ): Fx.RIO<never, Fiber<E2, any>> =>
-    Fx.fromPromise(async () => {
+  ): Fx.RIO<never, Fiber<E2, any>> => {
+    return Fx.lazy(() => {
+      const { f, __trace } = this
+
       const runtime = Runtime(context)
-      const cbSink = {
-        event: flow(sink.event, runtime.run),
-        error: flow(sink.error, runtime.run),
-        end: () => pipe(sink.end, runtime.run),
+      const tracedSink = addTrace(sink, __trace)
+      const cbSink: CallbackSink<E, A> = {
+        event: flow(tracedSink.event, runtime.run),
+        error: (cause) =>
+          pipe(
+            cause,
+            tracedSink.error,
+            Fx.tap(() => context.scope.close(Left(cause))),
+            runtime.run,
+          ),
+        end: () =>
+          pipe(
+            tracedSink.end,
+            Fx.tap(() => context.scope.close(Right(undefined))),
+            runtime.run,
+          ),
       }
-      const finalizer = await this.f(cbSink)
 
-      if (finalizer) {
-        context.scope.ensuring(finalizer)
-      }
+      const synthetic = fromScope(
+        new FiberId.Synthetic([context.id]),
+        context.fiberRefs,
+        context.scope,
+      )
 
-      const synthetic = Synthetic({
-        id: new FiberId.Synthetic([context.id]),
-        exit: wait(context.scope),
-        inheritFiberRefs: pipe(
-          Fx.getFiberRefs,
-          Fx.flatMap((refs) => Fx.fromLazy(() => FiberRefs.join(refs, context.fiberRefs))),
+      return pipe(
+        Fx.fromPromise(async () => await f(cbSink)),
+        Fx.tap(
+          (finalizer) =>
+            (finalizer &&
+              (context.scope.state.tag === 'Open'
+                ? Fx.fromLazy(() => context.scope.ensuring(finalizer))
+                : finalizer(context.scope.state.exit))) ??
+            Fx.unit,
         ),
-        interruptAs: (id) => closeOrWait(context.scope)(Exit.interrupt(id)),
-      })
-
-      return synthetic
+        Fx.fork,
+        Fx.map(() => synthetic),
+      )
     })
+  }
 }

package/src/Stream/fromFx.test.ts

@@ -1,38 +1,17 @@
 import { deepStrictEqual } from 'assert'
 
-import { pipe } from 'hkt-ts'
-
-import { collect, observe } from './drain.js'
+import { collectAll } from './_internal.test.js'
 import { fromFx } from './fromFx.js'
 
 import * as Fx from '@/Fx/index.js'
-import { RootScheduler } from '@/Scheduler/RootScheduler.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
 
 describe(new URL(import.meta.url).pathname, () => {
   describe(fromFx.name, () => {
     const value = Math.random()
     const stream = fromFx(Fx.success(value))
 
-    it('should create a Stream', () =>
-      pipe(
-        stream,
-        observe((n) => Fx.fromLazy(() => deepStrictEqual(n, value))),
-        Fx.flatMap(Fx.join),
-        Fx.provideService(Scheduler, RootScheduler()),
-        Fx.runMain,
-      ))
-
-    it('should be collectable', async () => {
-      await pipe(
-        Fx.Fx(function* () {
-          const events: readonly number[] = yield* collect(stream)
-
-          deepStrictEqual(events, [value])
-        }),
-        Fx.provideService(Scheduler, RootScheduler()),
-        Fx.runMain,
-      )
+    it('is collectable', async () => {
+      deepStrictEqual(await collectAll(stream), [value])
     })
   })
 })

package/src/Stream/fromFx.ts

@@ -1,45 +1,71 @@
 import { flow, pipe } from 'hkt-ts'
+import { Either } from 'hkt-ts/Either'
 
 import { Stream } from './Stream.js'
 
+import { Cause } from '@/Cause/Cause.js'
 import { Env } from '@/Env/Env.js'
+import * as Exit from '@/Exit/Exit.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/index.js'
 import * as Fx from '@/Fx/Fx.js'
-import { span } from '@/index.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
 
 /**
  * Constructs a Stream from an Fx that runs within a LogSpan enabling
  */
-export function makeFromFx(logSpan: string) {
-  return <R, E, A>(fx: Fx.Fx<R, E, A>, __trace?: string): Stream<R, E, A> => {
-    return Stream((sink, scheduler, context) =>
-      Fx.asksEnv(
-        (env: Env<R>) =>
-          scheduler.asap(
-            pipe(
-              fx,
-              Fx.matchCause(
-                sink.error,
-                flow(
-                  sink.event,
-                  Fx.flatMap(() => sink.end),
-                ),
+export function fromFx<R, E, A>(fx: Fx.Fx<R, E, A>, __trace?: string): Stream<R, E, A> {
+  return new FromFxStream(fx, __trace)
+}
+
+export class FromFxStream<R, E, A> implements Stream<R, E, A> {
+  constructor(readonly fx: Fx.Fx<R, E, A>, readonly __trace?: string) {}
+
+  fork<E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) {
+    return Fx.asksEnv(
+      (env: Env<R>) =>
+        scheduler.asap(
+          pipe(
+            this.fx,
+            Fx.matchCause(
+              sink.error,
+              flow(
+                sink.event,
+                Fx.flatMap(() => sink.end),
               ),
+              this.__trace,
             ),
-            env,
-            context,
-            span(logSpan),
           ),
-        __trace,
-      ),
+          env,
+          context,
+        ),
+      this.__trace,
     )
   }
 }
 
-export const fromFx = makeFromFx('Stream.fromFx')
-export const now = flow(Fx.now, makeFromFx('Stream.now'))
-export const fromCause = flow(Fx.fromCause, makeFromFx(`Stream.fromCause`))
-export const fromExit = flow(Fx.fromExit, makeFromFx(`Stream.fromExit`))
-export const fromPromise = flow(Fx.fromPromise, makeFromFx(`Stream.fromPromise`))
-export const fromLazy = flow(Fx.fromLazy, makeFromFx(`Stream.fromLazy`))
-export const fromEither = flow(Fx.fromEither, makeFromFx(`Stream.fromEither`))
-export const never = makeFromFx(`Stream.never`)(Fx.never)
+export const now = <A>(value: A, __trace?: string) => fromFx(Fx.now(value), __trace)
+
+export const fromCause = <E>(cause: Cause<E>, __trace?: string) =>
+  fromFx(Fx.fromCause(cause), __trace)
+
+export const fromExit = <E, A>(exit: Exit.Exit<E, A>, __trace?: string) =>
+  fromFx(Fx.fromExit(exit), __trace)
+
+export const interrupt = (id: FiberId, __trace?: string) => fromExit(Exit.interrupt(id), __trace)
+
+export const unexpected = (error: unknown, __trace?: string) =>
+  fromExit(Exit.unexpected(error), __trace)
+
+export const expected = <E>(error: E, __trace?: string) => fromExit(Exit.expected(error), __trace)
+
+export const fromPromise = <A>(promise: () => Promise<A>, __trace?: string) =>
+  fromFx(Fx.fromPromise(promise), __trace)
+
+export const fromLazy = <A>(lazy: () => A, __trace?: string) => fromFx(Fx.fromLazy(lazy), __trace)
+
+export const fromEither = <E, A>(either: Either<E, A>, __trace?: string) =>
+  fromFx(Fx.fromEither(either), __trace)
+
+export const never = fromFx(Fx.never, 'never')