effect 2.0.0-next.48 → 2.0.0-next.49

package/src/Chunk.ts

@@ -823,7 +823,7 @@ export const last = <A>(self: Chunk<A>): Option<A> => get(self, self.length - 1)
 export const unsafeLast = <A>(self: Chunk<A>): A => unsafeGet(self, self.length - 1)
 
 /**
- * Returns an effect whose success is mapped by the specified f function.
+ * Returns a chunk with the elements mapped by the specified f function.
  *
  * @since 2.0.0
  * @category mapping
@@ -836,6 +836,17 @@ export const map: {
     of(f(self.backing.a, 0)) :
     unsafeFromArray(pipe(toReadonlyArray(self), RA.map((a, i) => f(a, i)))))
 
+/**
+ * Returns a non empty chunk with the elements mapped by the specified f function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mapNonEmpty: {
+  <A, B>(f: (a: A, i: number) => B): (self: NonEmptyChunk<A>) => NonEmptyChunk<B>
+  <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => B): NonEmptyChunk<B>
+} = map as any
+
 /**
  * Statefully maps over the chunk, producing new elements of type `B`.
  *

package/src/Data.ts

@@ -164,11 +164,21 @@ export const Structural: new<A>(
  * @since 2.0.0
  * @category models
  */
-export type TaggedEnum<A extends Record<string, Record<string, any>>> = {
-  readonly [Tag in keyof A]: Data<
-    Readonly<Types.Simplify<A[Tag] & { _tag: Tag }>>
-  >
-}[keyof A]
+export type TaggedEnum<
+  A extends Record<string, Record<string, any>> & UntaggedChildren<A>
+> = keyof A extends infer Tag
+  ? Tag extends keyof A ? Data<{ readonly [K in `_tag` | keyof A[Tag]]: K extends `_tag` ? Tag : A[Tag][K] }>
+  : never
+  : never
+
+type ChildrenAreTagged<A> = keyof A extends infer K ? K extends keyof A ? "_tag" extends keyof A[K] ? true
+    : false
+  : never
+  : never
+
+type UntaggedChildren<A> = true extends ChildrenAreTagged<A>
+  ? "It looks like you're trying to create a tagged enum, but one or more of its members already has a `_tag` property."
+  : unknown
 
 /**
  * @since 2.0.0

package/src/HashMap.ts

@@ -35,6 +35,36 @@ export declare namespace HashMap {
    * @category models
    */
   export type UpdateFn<V> = (option: Option<V>) => Option<V>
+  /**
+   * This type-level utility extracts the key type `K` from a `HashMap<K, V>` type.
+   *
+   * @example
+   * import * as HashMap from "effect/HashMap"
+   *
+   * declare const hm: HashMap.HashMap<string, number>
+   *
+   * // $ExpectType string
+   * type K = HashMap.HashMap.Key<typeof hm>
+   *
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type Key<T extends HashMap<any, any>> = [T] extends [HashMap<infer _K, infer _V>] ? _K : never
+  /**
+   * This type-level utility extracts the value type `V` from a `HashMap<K, V>` type.
+   *
+   * @example
+   * import * as HashMap from "effect/HashMap"
+   *
+   * declare const hm: HashMap.HashMap<string, number>
+   *
+   * // $ExpectType number
+   * type V = HashMap.HashMap.Value<typeof hm>
+   *
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type Value<T extends HashMap<any, any>> = [T] extends [HashMap<infer _K, infer _V>] ? _V : never
 }
 
 /**

package/src/List.ts

@@ -736,6 +736,15 @@ export const map: {
   }
 })
 
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapNonEmpty: {
+  <A, B>(f: (a: A) => B): (self: Cons<A>) => Cons<B>
+  <A, B>(self: Cons<A>, f: (a: A) => B): Cons<B>
+} = map as any
+
 /**
  * Partition a list into two lists, where the first list contains all elements
  * that did not satisfy the specified predicate, and the second list contains

package/src/Metric.ts

@@ -156,7 +156,26 @@ export const mapInput: {
 } = internal.mapInput
 
 /**
- * A counter, which can be incremented by numbers.
+ * Represents a Counter metric that tracks cumulative numerical values over time.
+ * Counters can be incremented and decremented and provide a running total of changes.
+ *
+ * @param name - The name of the counter metric.
+ * @param options - An optional configuration for the counter:
+ * - description - A description of the counter.
+ * - bigint - Indicates if the counter uses 'bigint' data type.
+ * - incremental - Set to 'true' for a counter that only increases. With this configuration, Effect ensures that non-incremental updates have no impact on the counter, making it exclusively suitable for counting upwards.
+ *
+ * @example
+ * import * as Metric from "effect/Metric"
+ *
+ * const numberCounter = Metric.counter("count", {
+ *   description: "A number counter"
+ * });
+ *
+ * const bigintCounter = Metric.counter("count", {
+ *   description: "A bigint counter",
+ *   bigint: true
+ * });
  *
  * @since 2.0.0
  * @category constructors
@@ -181,8 +200,16 @@ export const counter: {
 } = internal.counter
 
 /**
- * A string histogram metric, which keeps track of the counts of different
- * strings.
+ * Creates a Frequency metric to count occurrences of events.
+ * Frequency metrics are used to count the number of times specific events or incidents occur.
+ *
+ * @param name - The name of the Frequency metric.
+ * @param description - An optional description of the Frequency metric.
+ *
+ * @example
+ * import * as Metric from "effect/Metric"
+ *
+ * const errorFrequency = Metric.frequency("error_frequency", "Counts the occurrences of errors.");
  *
  * @since 2.0.0
  * @category constructors
@@ -212,7 +239,25 @@ export const fromMetricKey: <Type extends MetricKeyType.MetricKeyType<any, any>>
   internal.fromMetricKey
 
 /**
- * A gauge, which can be set to a value.
+ * Represents a Gauge metric that tracks and reports a single numerical value at a specific moment.
+ * Gauges are suitable for metrics that represent instantaneous values, such as memory usage or CPU load.
+ *
+ * @param name - The name of the gauge metric.
+ * @param options - An optional configuration for the gauge:
+ * - description - A description of the gauge metric.
+ * - bigint - Indicates if the counter uses 'bigint' data type.
+ *
+ * @example
+ * import * as Metric from "effect/Metric"
+ *
+ * const numberGauge = Metric.gauge("memory_usage", {
+ *   description: "A gauge for memory usage"
+ * });
+ *
+ * const bigintGauge = Metric.gauge("cpu_load", {
+ *   description: "A gauge for CPU load",
+ *   bigint: true
+ * });
  *
  * @since 2.0.0
  * @category constructors
@@ -223,8 +268,21 @@ export const gauge: {
 } = internal.gauge
 
 /**
- * A numeric histogram metric, which keeps track of the count of numbers that
- * fall in bins with the specified boundaries.
+ * Represents a Histogram metric that records observations in specified value boundaries.
+ * Histogram metrics are useful for measuring the distribution of values within a range.
+ *
+ * @param name - The name of the histogram metric.
+ * @param boundaries - The boundaries for defining the histogram's value ranges.
+ * @param description - A description of the histogram metric.
+ *
+ * @example
+ * import * as Metric from "effect/Metric"
+ * import * as MetricBoundaries from "effect/MetricBoundaries"
+ *
+ * const latencyHistogram = Metric.histogram("latency_histogram",
+ *   MetricBoundaries.linear({ start: 0, width: 10, count: 11 }),
+ *   "Measures the distribution of request latency."
+ * );
  *
  * @since 2.0.0
  * @category constructors
@@ -311,6 +369,30 @@ export const succeed: <Out>(out: Out) => Metric<void, unknown, Out> = internal.s
 export const sync: <Out>(evaluate: LazyArg<Out>) => Metric<void, unknown, Out> = internal.sync
 
 /**
+ * Creates a Summary metric that records observations and calculates quantiles.
+ * Summary metrics provide statistical information about a set of values, including quantiles.
+ *
+ * @param options - An object with configuration options for the Summary metric:
+ * - name - The name of the Summary metric.
+ * - maxAge - The maximum age of observations to retain.
+ * - maxSize - The maximum number of observations to keep.
+ * - error - The error percentage when calculating quantiles.
+ * - quantiles - An `Chunk` of quantiles to calculate (e.g., [0.5, 0.9]).
+ * - description - An optional description of the Summary metric.
+ *
+ * @example
+ * import * as Metric from "effect/Metric"
+ * import * as Chunk from "effect/Chunk"
+ *
+ * const responseTimesSummary = Metric.summary({
+ *   name: "response_times_summary",
+ *   maxAge: "60 seconds", // Retain observations for 60 seconds.
+ *   maxSize: 1000, // Keep a maximum of 1000 observations.
+ *   error: 0.01, // Allow a 1% error when calculating quantiles.
+ *   quantiles: Chunk.make(0.5, 0.9, 0.99), // Calculate 50th, 90th, and 99th percentiles.
+ *   description: "Measures the distribution of response times."
+ * });
+ *
  * @since 2.0.0
  * @category constructors
  */

package/src/TRef.ts

@@ -53,7 +53,7 @@ export interface TRef<A> {
 /**
  * @since 2.0.0
  */
-export namespace TRef {
+export declare namespace TRef {
   /**
    * @since 2.0.0
    */

package/src/internal/cause.ts

@@ -59,7 +59,7 @@ const proto = {
         return { _id: "Cause", _tag: this._tag, failure: toJSON(this.error) }
       case "Sequential":
       case "Parallel":
-        return { _id: "Cause", _tag: this._tag, errors: toJSON(prettyErrors(this)) }
+        return { _id: "Cause", _tag: this._tag, left: toJSON(this.left), right: toJSON(this.right) }
     }
   },
   toString<E>(this: Cause.Cause<E>) {

package/src/internal/channel.ts

@@ -1176,6 +1176,7 @@ export const mergeAllWith = (
 > =>
   pipe(
     Effect.gen(function*($) {
+      const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : concurrency
       const input = yield* $(singleProducerAsyncInput.make<
         InErr & InErr1,
         InElem & InElem1,
@@ -1196,9 +1197,8 @@ export const mergeAllWith = (
       )
       const lastDone = yield* $(Ref.make<Option.Option<OutDone>>(Option.none()))
       const errorSignal = yield* $(Deferred.make<never, void>())
-      const withPermits = concurrency === "unbounded" ?
-        ((_: number) => identity) :
-        (yield* $(Effect.makeSemaphore(concurrency))).withPermits
+      const withPermits = (yield* $(Effect.makeSemaphore(concurrencyN)))
+        .withPermits
       const pull = yield* $(toPull(channels))
       const evaluatePull = (
         pull: Effect.Effect<Env | Env1, OutErr | OutErr1, Either.Either<OutDone, OutElem>>
@@ -1216,23 +1216,21 @@ export const mergeAllWith = (
             })
           ),
           Effect.repeatUntil(Option.isSome),
-          Effect.flatMap(Option.match({
-            onNone: () => Effect.unit,
-            onSome: (outDone) =>
-              Ref.update(
-                lastDone,
-                Option.match({
-                  onNone: () => Option.some(outDone),
-                  onSome: (lastDone) => Option.some(f(lastDone, outDone))
-                })
-              )
-          })),
+          Effect.flatMap((outDone) =>
+            Ref.update(
+              lastDone,
+              Option.match({
+                onNone: () => Option.some(outDone.value),
+                onSome: (lastDone) => Option.some(f(lastDone, outDone.value))
+              })
+            )
+          ),
           Effect.catchAllCause((cause) =>
             Cause.isInterrupted(cause) ?
               Effect.failCause(cause) :
               pipe(
                 Queue.offer(queue, Effect.failCause(cause)),
-                Effect.zipRight(Deferred.succeed<never, void>(errorSignal, void 0)),
+                Effect.zipRight(Deferred.succeed(errorSignal, void 0)),
                 Effect.asUnit
               )
           )
@@ -1246,88 +1244,83 @@ export const mergeAllWith = (
             ),
           onSuccess: Either.match({
             onLeft: (outDone) =>
-              Effect.raceWith(Deferred.await(errorSignal), withPermits(concurrency as number)(Effect.unit), {
-                onSelfDone: (_, permitAcquisition) => pipe(Fiber.interrupt(permitAcquisition), Effect.as(false)),
+              Effect.raceWith(Deferred.await(errorSignal), withPermits(concurrencyN)(Effect.unit), {
+                onSelfDone: (_, permitAcquisition) => Effect.as(Fiber.interrupt(permitAcquisition), false),
                 onOtherDone: (_, failureAwait) =>
-                  pipe(
+                  Effect.zipRight(
                     Fiber.interrupt(failureAwait),
-                    Effect.zipRight(
-                      pipe(
-                        Ref.get(lastDone),
-                        Effect.flatMap(Option.match({
-                          onNone: () => Queue.offer(queue, Effect.succeed(Either.left(outDone))),
-                          onSome: (lastDone) => Queue.offer(queue, Effect.succeed(Either.left(f(lastDone, outDone))))
-                        })),
-                        Effect.as(false)
-                      )
+                    pipe(
+                      Ref.get(lastDone),
+                      Effect.flatMap(Option.match({
+                        onNone: () => Queue.offer(queue, Effect.succeed(Either.left(outDone))),
+                        onSome: (lastDone) => Queue.offer(queue, Effect.succeed(Either.left(f(lastDone, outDone))))
+                      })),
+                      Effect.as(false)
                     )
                   )
               }),
             onRight: (channel) =>
-              pipe(
-                mergeStrategy,
-                _mergeStrategy.match({
-                  onBackPressure: () =>
-                    Effect.gen(function*($) {
-                      const latch = yield* $(Deferred.make<never, void>())
-                      const raceEffects: Effect.Effect<Env | Env1, OutErr | OutErr1, void> = pipe(
-                        queueReader,
-                        core.pipeTo(channel),
-                        toPull,
-                        Effect.flatMap((pull) =>
-                          pipe(
-                            evaluatePull(pull),
-                            Effect.race(Deferred.await(errorSignal))
-                          )
-                        ),
-                        Effect.scoped
-                      )
-                      yield* $(
-                        Deferred.succeed<never, void>(latch, void 0),
-                        Effect.zipRight(raceEffects),
-                        withPermits(1),
-                        Effect.forkScoped
-                      )
-                      yield* $(Deferred.await(latch))
-                      const errored = yield* $(Deferred.isDone(errorSignal))
-                      return !errored
-                    }),
-                  onBufferSliding: () =>
-                    Effect.gen(function*($) {
-                      const canceler = yield* $(Deferred.make<never, void>())
-                      const latch = yield* $(Deferred.make<never, void>())
-                      const size = yield* $(Queue.size(cancelers))
-                      yield* $(
-                        Queue.take(cancelers),
-                        Effect.flatMap((_) => Deferred.succeed<never, void>(_, void 0)),
-                        Effect.when(() => concurrency === "unbounded" ? false : size >= concurrency)
-                      )
-                      yield* $(Queue.offer(cancelers, canceler))
-                      const raceEffects: Effect.Effect<Env | Env1, OutErr | OutErr1, void> = pipe(
-                        queueReader,
-                        core.pipeTo(channel),
-                        toPull,
-                        Effect.flatMap((pull) =>
-                          pipe(
-                            evaluatePull(pull),
-                            Effect.race(Deferred.await(errorSignal)),
-                            Effect.race(Deferred.await(canceler))
-                          )
-                        ),
-                        Effect.scoped
-                      )
-                      yield* $(
-                        Deferred.succeed<never, void>(latch, void 0),
-                        Effect.zipRight(raceEffects),
-                        withPermits(1),
-                        Effect.forkScoped
-                      )
-                      yield* $(Deferred.await(latch))
-                      const errored = yield* $(Deferred.isDone(errorSignal))
-                      return !errored
-                    })
-                })
-              )
+              _mergeStrategy.match(mergeStrategy, {
+                onBackPressure: () =>
+                  Effect.gen(function*($) {
+                    const latch = yield* $(Deferred.make<never, void>())
+                    const raceEffects: Effect.Effect<Env | Env1, OutErr | OutErr1, void> = pipe(
+                      queueReader,
+                      core.pipeTo(channel),
+                      toPull,
+                      Effect.flatMap((pull) =>
+                        Effect.race(
+                          evaluatePull(pull),
+                          Deferred.await(errorSignal)
+                        )
+                      ),
+                      Effect.scoped
+                    )
+                    yield* $(
+                      Deferred.succeed<never, void>(latch, void 0),
+                      Effect.zipRight(raceEffects),
+                      withPermits(1),
+                      Effect.forkScoped
+                    )
+                    yield* $(Deferred.await(latch))
+                    const errored = yield* $(Deferred.isDone(errorSignal))
+                    return !errored
+                  }),
+                onBufferSliding: () =>
+                  Effect.gen(function*($) {
+                    const canceler = yield* $(Deferred.make<never, void>())
+                    const latch = yield* $(Deferred.make<never, void>())
+                    const size = yield* $(Queue.size(cancelers))
+                    yield* $(
+                      Queue.take(cancelers),
+                      Effect.flatMap((_) => Deferred.succeed<never, void>(_, void 0)),
+                      Effect.when(() => size >= concurrencyN)
+                    )
+                    yield* $(Queue.offer(cancelers, canceler))
+                    const raceEffects: Effect.Effect<Env | Env1, OutErr | OutErr1, void> = pipe(
+                      queueReader,
+                      core.pipeTo(channel),
+                      toPull,
+                      Effect.flatMap((pull) =>
+                        pipe(
+                          evaluatePull(pull),
+                          Effect.race(Deferred.await(errorSignal)),
+                          Effect.race(Deferred.await(canceler))
+                        )
+                      ),
+                      Effect.scoped
+                    )
+                    yield* $(
+                      Deferred.succeed<never, void>(latch, void 0),
+                      Effect.zipRight(raceEffects),
+                      withPermits(1),
+                      Effect.forkScoped
+                    )
+                    yield* $(Deferred.await(latch))
+                    const errored = yield* $(Deferred.isDone(errorSignal))
+                    return !errored
+                  })
+              })
           })
         }),
         Effect.repeatWhile(identity),

package/src/internal/groupBy.ts

@@ -35,6 +35,10 @@ const groupByVariance = {
   _V: (_: never) => _
 }
 
+/** @internal */
+export const isGroupBy = (u: unknown): u is GroupBy.GroupBy<unknown, unknown, unknown, unknown> =>
+  typeof u === "object" && u != null && GroupByTypeId in u
+
 /** @internal */
 export const evaluate = dual<
   <K, E, V, R2, E2, A>(
@@ -47,7 +51,7 @@ export const evaluate = dual<
     options?: { readonly bufferSize?: number }
   ) => Stream.Stream<R2 | R, E | E2, A>
 >(
-  3,
+  (args) => isGroupBy(args[0]),
   <R, K, E, V, R2, E2, A>(
     self: GroupBy.GroupBy<R, E, K, V>,
     f: (key: K, stream: Stream.Stream<never, E, V>) => Stream.Stream<R2, E2, A>,
@@ -122,7 +126,7 @@ export const groupBy = dual<
     options?: { readonly bufferSize?: number }
   ) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>
 >(
-  (args) => typeof args[0] !== "function",
+  (args) => stream.isStream(args[0]),
   <R, E, A, R2, E2, K, V>(
     self: Stream.Stream<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, readonly [K, V]>,
@@ -240,7 +244,7 @@ export const mapEffectOptions = dual<
     if (options?.key) {
       return evaluate(
         groupByKey(self, options.key, { bufferSize: options.bufferSize }),
-        (_, s) => pipe(s, stream.mapEffectSequential(f))
+        (_, s) => stream.mapEffectSequential(s, f)
       )
     }
 

package/src/internal/stream.ts

@@ -2613,12 +2613,12 @@ export const flatMap = dual<
               )
           )
         ),
-      (n) =>
+      (_) =>
         new StreamImpl(
           pipe(
             toChannel(self),
             channel.concatMap(channel.writeChunk),
-            channel.mergeMap((out) => toChannel(f(out)), { concurrency: n, bufferSize })
+            channel.mergeMap((out) => toChannel(f(out)), options as any)
           )
         )
     )
@@ -2635,7 +2635,7 @@ export const matchConcurrency = <A>(
     case undefined:
       return sequential()
     case "unbounded":
-      return bounded(Number.POSITIVE_INFINITY)
+      return bounded(Number.MAX_SAFE_INTEGER)
     default:
       return concurrency > 1 ? bounded(concurrency) : sequential()
   }
@@ -2980,10 +2980,13 @@ export const fromIteratorSucceed = <A>(
             }
             builder = []
             let count = 0
-            while (count < maxChunkSize && !next.done) {
+            while (next.done === false) {
               builder.push(next.value)
-              next = iterator.next()
               count = count + 1
+              if (count >= maxChunkSize) {
+                break
+              }
+              next = iterator.next()
             }
             if (count > 0) {
               return pipe(

package/src/tsconfig.json

@@ -33,7 +33,15 @@
     "target": "ES2021",
     "module": "ES6",
     "incremental": true,
-    "removeComments": false
+    "removeComments": false,
+    "paths": {
+      "effect": [
+        "./index.ts"
+      ],
+      "effect/*": [
+        "./*.ts"
+      ]
+    }
   },
   "include": [
     "**/*"