effect 3.5.9 → 3.6.0

package/src/internal/core.ts

@@ -1250,6 +1250,12 @@ export const tap = dual<
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
+    <A, X, E1, R1>(
+      f: (a: NoInfer<A>) => Effect.Effect<X, E1, R1>,
+      options: { onlyEffect: true }
+    ): <E, R>(
+      self: Effect.Effect<A, E, R>
+    ) => Effect.Effect<A, E | E1, R | R1>
     <X>(
       f: NotFunction<X>
     ): <A, E, R>(
@@ -1257,6 +1263,12 @@ export const tap = dual<
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
+    <X, E1, R1>(
+      f: Effect.Effect<X, E1, R1>,
+      options: { onlyEffect: true }
+    ): <A, E, R>(
+      self: Effect.Effect<A, E, R>
+    ) => Effect.Effect<A, E | E1, R | R1>
   },
   {
     <A, E, R, X>(
@@ -1265,25 +1277,38 @@ export const tap = dual<
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
+    <A, E, R, X, E1, R1>(
+      self: Effect.Effect<A, E, R>,
+      f: (a: NoInfer<A>) => Effect.Effect<X, E1, R1>,
+      options: { onlyEffect: true }
+    ): Effect.Effect<A, E | E1, R | R1>
     <A, E, R, X>(
       self: Effect.Effect<A, E, R>,
       f: NotFunction<X>
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
+    <A, E, R, X, E1, R1>(
+      self: Effect.Effect<A, E, R>,
+      f: Effect.Effect<X, E1, R1>,
+      options: { onlyEffect: true }
+    ): Effect.Effect<A, E | E1, R | R1>
   }
->(2, (self, f) =>
-  flatMap(self, (a) => {
-    const b = typeof f === "function" ? (f as any)(a) : f
-    if (isEffect(b)) {
-      return as(b, a)
-    } else if (isPromiseLike(b)) {
-      return async<any, Cause.UnknownException>((resume) => {
-        b.then((_) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
-      })
-    }
-    return succeed(a)
-  }))
+>(
+  (args) => args.length === 3 || args.length === 2 && !(isObject(args[1]) && "onlyEffect" in args[1]),
+  <A, E, R, X>(self: Effect.Effect<A, E, R>, f: X) =>
+    flatMap(self, (a) => {
+      const b = typeof f === "function" ? (f as any)(a) : f
+      if (isEffect(b)) {
+        return as(b, a)
+      } else if (isPromiseLike(b)) {
+        return async<any, Cause.UnknownException>((resume) => {
+          b.then((_) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
+        })
+      }
+      return succeed(a)
+    })
+)
 
 /* @internal */
 export const transplant = <A, E, R>(

package/src/internal/defaultServices.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import type * as Chunk from "../Chunk.js"
 import type * as Clock from "../Clock.js"
 import type * as Config from "../Config.js"
@@ -133,6 +134,19 @@ export const nextIntBetween = (min: number, max: number): Effect.Effect<number>
 export const shuffle = <A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>> =>
   randomWith((random) => random.shuffle(elements))
 
+/** @internal */
+export const choice = <Self extends Iterable<unknown>>(
+  elements: Self
+) => {
+  const array = Array.fromIterable(elements)
+  return core.map(
+    array.length === 0
+      ? core.fail(new core.NoSuchElementException("Cannot select a random element from an empty array"))
+      : randomWith((random) => random.nextIntBetween(0, array.length)),
+    (i) => array[i]
+  ) as any
+}
+
 // circular with Tracer
 
 /** @internal */

package/src/internal/metric/registry.ts

@@ -27,7 +27,7 @@ class MetricRegistryImpl implements MetricRegistry.MetricRegistry {
     MetricHook.MetricHook.Root
   >()
 
-  snapshot(): ReadonlyArray<MetricPair.MetricPair.Untyped> {
+  snapshot(): Array<MetricPair.MetricPair.Untyped> {
     const result: Array<MetricPair.MetricPair.Untyped> = []
     for (const [key, hook] of this.map) {
       result.push(metricPair.unsafeMake(key, hook.get()))

package/src/internal/metric.ts

@@ -525,9 +525,9 @@ export const zip = dual<
 )
 
 /** @internal */
-export const unsafeSnapshot = (): ReadonlyArray<MetricPair.MetricPair.Untyped> => globalMetricRegistry.snapshot()
+export const unsafeSnapshot = (): Array<MetricPair.MetricPair.Untyped> => globalMetricRegistry.snapshot()
 
 /** @internal */
-export const snapshot: Effect.Effect<ReadonlyArray<MetricPair.MetricPair.Untyped>> = core.sync(
+export const snapshot: Effect.Effect<Array<MetricPair.MetricPair.Untyped>> = core.sync(
   unsafeSnapshot
 )

package/src/internal/stream/emit.ts

@@ -4,6 +4,8 @@ import * as Effect from "../../Effect.js"
 import * as Exit from "../../Exit.js"
 import { pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
+import type * as Queue from "../../Queue.js"
+import type * as Scheduler from "../../Scheduler.js"
 import type * as Emit from "../../StreamEmit.js"
 
 /** @internal */
@@ -44,3 +46,78 @@ export const make = <R, E, A, B>(
   }
   return Object.assign(emit, ops)
 }
+
+/** @internal */
+export const makePush = <E, A>(
+  queue: Queue.Queue<Array<A> | Exit.Exit<void, E>>,
+  scheduler: Scheduler.Scheduler
+): Emit.EmitOpsPush<E, A> => {
+  let finished = false
+  let buffer: Array<A> = []
+  let running = false
+  function array(items: ReadonlyArray<A>) {
+    if (finished) return false
+    if (items.length <= 50_000) {
+      buffer.push.apply(buffer, items as Array<A>)
+    } else {
+      for (let i = 0; i < items.length; i++) {
+        buffer.push(items[0])
+      }
+    }
+    if (!running) {
+      running = true
+      scheduler.scheduleTask(flush, 0)
+    }
+    return true
+  }
+  function flush() {
+    running = false
+    if (buffer.length > 0) {
+      queue.unsafeOffer(buffer)
+      buffer = []
+    }
+  }
+  function done(exit: Exit.Exit<A, E>) {
+    if (finished) return
+    finished = true
+    if (exit._tag === "Success") {
+      buffer.push(exit.value)
+    }
+    flush()
+    queue.unsafeOffer(exit._tag === "Success" ? Exit.void : exit)
+  }
+  return {
+    single(value: A) {
+      if (finished) return false
+      buffer.push(value)
+      if (!running) {
+        running = true
+        scheduler.scheduleTask(flush, 0)
+      }
+      return true
+    },
+    array,
+    chunk(chunk) {
+      return array(Chunk.toReadonlyArray(chunk))
+    },
+    done,
+    end() {
+      if (finished) return
+      finished = true
+      flush()
+      queue.unsafeOffer(Exit.void)
+    },
+    halt(cause: Cause.Cause<E>) {
+      return done(Exit.failCause(cause))
+    },
+    fail(error: E) {
+      return done(Exit.fail(error))
+    },
+    die<Err>(defect: Err): void {
+      return done(Exit.die(defect))
+    },
+    dieMessage(message: string): void {
+      return done(Exit.die(new Error(message)))
+    }
+  }
+}

package/src/internal/stream.ts

@@ -10,6 +10,7 @@ import * as Either from "../Either.js"
 import * as Equal from "../Equal.js"
 import * as Exit from "../Exit.js"
 import * as Fiber from "../Fiber.js"
+import * as FiberRef from "../FiberRef.js"
 import type { LazyArg } from "../Function.js"
 import { constTrue, dual, identity, pipe } from "../Function.js"
 import * as Layer from "../Layer.js"
@@ -597,6 +598,51 @@ export const asyncEffect = <A, E = never, R = never>(
     fromChannel
   )
 
+const queueFromBufferOptionsPush = <A, E>(
+  options?: { readonly bufferSize: "unbounded" } | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | undefined
+  } | undefined
+): Effect.Effect<Queue.Queue<Array<A> | Exit.Exit<void, E>>> => {
+  if (options?.bufferSize === "unbounded" || (options?.bufferSize === undefined && options?.strategy === undefined)) {
+    return Queue.unbounded()
+  }
+  switch (options?.strategy) {
+    case "sliding":
+      return Queue.sliding(options.bufferSize ?? 16)
+    default:
+      return Queue.dropping(options?.bufferSize ?? 16)
+  }
+}
+
+/** @internal */
+export const asyncPush = <A, E = never, R = never>(
+  register: (emit: Emit.EmitOpsPush<E, A>) => Effect.Effect<unknown, never, R | Scope.Scope>,
+  options?: {
+    readonly bufferSize: "unbounded"
+  } | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | undefined
+  } | undefined
+): Stream.Stream<A, E, Exclude<R, Scope.Scope>> =>
+  Effect.acquireRelease(
+    queueFromBufferOptionsPush<A, E>(options),
+    Queue.shutdown
+  ).pipe(
+    Effect.tap((queue) =>
+      FiberRef.getWith(FiberRef.currentScheduler, (scheduler) => register(emit.makePush(queue, scheduler)))
+    ),
+    Effect.map((queue) => {
+      const loop: Channel.Channel<Chunk.Chunk<A>, unknown, E> = core.flatMap(Queue.take(queue), (item) =>
+        Exit.isExit(item)
+          ? Exit.isSuccess(item) ? core.void : core.failCause(item.cause)
+          : channel.zipRight(core.write(Chunk.unsafeFromArray(item)), loop))
+      return loop
+    }),
+    channel.unwrapScoped,
+    fromChannel
+  )
+
 /** @internal */
 export const asyncScoped = <A, E = never, R = never>(
   register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R | Scope.Scope>,
@@ -4116,6 +4162,23 @@ export const mkString = <E, R>(self: Stream.Stream<string, E, R>): Effect.Effect
 /** @internal */
 export const never: Stream.Stream<never> = fromEffect(Effect.never)
 
+/** @internal */
+export const onEnd: {
+  <_, E2, R2>(
+    effect: Effect.Effect<_, E2, R2>
+  ): <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E2 | E, R2 | R>
+  <A, E, R, _, E2, R2>(
+    self: Stream.Stream<A, E, R>,
+    effect: Effect.Effect<_, E2, R2>
+  ): Stream.Stream<A, E | E2, R | R2>
+} = dual(
+  2,
+  <A, E, R, _, E2, R2>(
+    self: Stream.Stream<A, E, R>,
+    effect: Effect.Effect<_, E2, R2>
+  ): Stream.Stream<A, E | E2, R | R2> => concat(self, drain(fromEffect(effect)))
+)
+
 /** @internal */
 export const onError = dual<
   <E, X, R2>(
@@ -4154,6 +4217,23 @@ export const onDone = dual<
     )
 )
 
+/** @internal */
+export const onStart: {
+  <_, E2, R2>(
+    effect: Effect.Effect<_, E2, R2>
+  ): <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E2 | E, R2 | R>
+  <A, E, R, _, E2, R2>(
+    self: Stream.Stream<A, E, R>,
+    effect: Effect.Effect<_, E2, R2>
+  ): Stream.Stream<A, E | E2, R | R2>
+} = dual(
+  2,
+  <A, E, R, _, E2, R2>(
+    self: Stream.Stream<A, E, R>,
+    effect: Effect.Effect<_, E2, R2>
+  ): Stream.Stream<A, E | E2, R | R2> => unwrap(Effect.as(effect, self))
+)
+
 /** @internal */
 export const orDie = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, never, R> =>
   pipe(self, orDieWith(identity))
@@ -8324,23 +8404,11 @@ export const fromEventListener = <A = unknown>(
     readonly capture?: boolean
     readonly passive?: boolean
     readonly once?: boolean
+    readonly bufferSize?: number | "unbounded" | undefined
   } | undefined
 ): Stream.Stream<A> =>
-  _async<A>((emit) => {
-    let batch: Array<A> = []
-    let taskRunning = false
-    function cb(e: A) {
-      batch.push(e)
-      if (!taskRunning) {
-        taskRunning = true
-        queueMicrotask(() => {
-          const events = batch
-          batch = []
-          taskRunning = false
-          emit.chunk(Chunk.unsafeFromArray(events))
-        })
-      }
-    }
-    target.addEventListener(type, cb as any, options)
-    return Effect.sync(() => target.removeEventListener(type, cb, options))
-  }, "unbounded")
+  asyncPush<A>((emit) =>
+    Effect.acquireRelease(
+      Effect.sync(() => target.addEventListener(type, emit.single as any, options)),
+      () => Effect.sync(() => target.removeEventListener(type, emit.single, options))
+    ), { bufferSize: typeof options === "object" ? options.bufferSize : undefined })

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.5.9"
+let moduleVersion = "3.6.0"
 
 export const getCurrentVersion = () => moduleVersion