effect 3.6.4 → 3.6.6

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.6.4";
+let moduleVersion = "3.6.6";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.6.4",
+  "version": "3.6.6",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Metric.ts

@@ -56,6 +56,7 @@ export interface Metric<in out Type, in In, out Out> extends Metric.Variance<Typ
   readonly keyType: Type
   unsafeUpdate(input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>): void
   unsafeValue(extraTags: ReadonlyArray<MetricLabel.MetricLabel>): Out
+  unsafeModify(input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>): void
   register(): this
   <A extends In, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
 }
@@ -68,7 +69,8 @@ export interface MetricApply {
   <Type, In, Out>(
     keyType: Type,
     unsafeUpdate: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void,
-    unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out
+    unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out,
+    unsafeModify: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void
   ): Metric<Type, In, Out>
 }
 
@@ -306,20 +308,21 @@ export const histogram: (
 
 /**
  * @since 2.0.0
- * @category aspects
+ * @category combinators
  */
-export const increment: (self: Metric.Counter<number> | Metric.Counter<bigint>) => Effect.Effect<void> =
-  internal.increment
+export const increment: (
+  self: Metric.Counter<number> | Metric.Counter<bigint> | Metric.Gauge<number> | Metric.Gauge<bigint>
+) => Effect.Effect<void> = internal.increment
 
 /**
  * @since 2.0.0
- * @category aspects
+ * @category combinators
  */
 export const incrementBy: {
-  (amount: number): (self: Metric.Counter<number>) => Effect.Effect<void>
-  (amount: bigint): (self: Metric.Counter<bigint>) => Effect.Effect<void>
-  (self: Metric.Counter<number>, amount: number): Effect.Effect<void>
-  (self: Metric.Counter<bigint>, amount: bigint): Effect.Effect<void>
+  (amount: number): (self: Metric.Counter<number> | Metric.Counter<number>) => Effect.Effect<void>
+  (amount: bigint): (self: Metric.Counter<bigint> | Metric.Gauge<bigint>) => Effect.Effect<void>
+  (self: Metric.Counter<number> | Metric.Gauge<number>, amount: number): Effect.Effect<void>
+  (self: Metric.Counter<bigint> | Metric.Gauge<bigint>, amount: bigint): Effect.Effect<void>
 } = internal.incrementBy
 
 /**
@@ -344,6 +347,19 @@ export const mapType: {
   <Type, In, Out, Type2>(self: Metric<Type, In, Out>, f: (type: Type) => Type2): Metric<Type2, In, Out>
 } = internal.mapType
 
+/**
+ * Modifies the metric with the specified update message. For example, if the
+ * metric were a gauge, the update would increment the method by the provided
+ * amount.
+ *
+ * @since 3.6.5
+ * @category utils
+ */
+export const modify: {
+  <In>(input: In): <Type, Out>(self: Metric<Type, In, Out>) => Effect.Effect<void>
+  <Type, In, Out>(self: Metric<Type, In, Out>, input: In): Effect.Effect<void>
+} = internal.modify
+
 /**
  * @since 2.0.0
  * @category aspects

package/src/MetricHook.ts

@@ -27,6 +27,7 @@ export type MetricHookTypeId = typeof MetricHookTypeId
 export interface MetricHook<in In, out Out> extends MetricHook.Variance<In, Out>, Pipeable {
   get(): Out
   update(input: In): void
+  modify(input: In): void
 }
 
 /**
@@ -94,6 +95,7 @@ export declare namespace MetricHook {
 export const make: <In, Out>(options: {
   readonly get: LazyArg<Out>
   readonly update: (input: In) => void
+  readonly modify: (input: In) => void
 }) => MetricHook<In, Out> = internal.make
 
 /**
@@ -138,3 +140,12 @@ export const onUpdate: {
   <In, Out>(f: (input: In) => void): (self: MetricHook<In, Out>) => MetricHook<In, Out>
   <In, Out>(self: MetricHook<In, Out>, f: (input: In) => void): MetricHook<In, Out>
 } = internal.onUpdate
+
+/**
+ * @since 3.6.5
+ * @category utils
+ */
+export const onModify: {
+  <In, Out>(f: (input: In) => void): (self: MetricHook<In, Out>) => MetricHook<In, Out>
+  <In, Out>(self: MetricHook<In, Out>, f: (input: In) => void): MetricHook<In, Out>
+} = internal.onModify

package/src/Pipeable.ts

@@ -7,6 +7,7 @@
  * @category models
  */
 export interface Pipeable {
+  pipe<A>(this: A): A
   pipe<A, B>(this: A, ab: (_: A) => B): B
   pipe<A, B, C>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
   pipe<A, B, C, D>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D
@@ -289,6 +290,8 @@ export interface Pipeable {
  */
 export const pipeArguments = <A>(self: A, args: IArguments): unknown => {
   switch (args.length) {
+    case 0:
+      return self
     case 1:
       return args[0](self)
     case 2:

package/src/Stream.ts

@@ -1009,8 +1009,8 @@ export const concatAll: <A, E, R>(streams: Chunk.Chunk<Stream<A, E, R>>) => Stre
 
 /**
  * Composes this stream with the specified stream to create a cartesian
- * product of elements. The `that` stream would be run multiple times, for
- * every element in the `this` stream.
+ * product of elements. The `right` stream would be run multiple times, for
+ * every element in the `left` stream.
  *
  * See also `Stream.zip` for the more common point-wise variant.
  *
@@ -1034,14 +1034,14 @@ export const concatAll: <A, E, R>(streams: Chunk.Chunk<Stream<A, E, R>>) => Stre
  * @category utils
  */
 export const cross: {
-  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>
+  <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<[AL, AR], EL | ER, RL | RR>
+  <AL, ER, RR, AR, EL, RL>(left: Stream<AL, ER, RR>, right: Stream<AR, EL, RL>): Stream<[AL, AR], EL | ER, RL | RR>
 } = internal.cross
 
 /**
  * Composes this stream with the specified stream to create a cartesian
- * product of elements, but keeps only elements from this stream. The `that`
- * stream would be run multiple times, for every element in the `this` stream.
+ * product of elements, but keeps only elements from `left` stream. The `right`
+ * stream would be run multiple times, for every element in the `left` stream.
  *
  * See also `Stream.zipLeft` for the more common point-wise variant.
  *
@@ -1049,14 +1049,14 @@ export const cross: {
  * @category utils
  */
 export const crossLeft: {
-  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>
+  <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AL, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AL, EL | ER, RL | RR>
 } = internal.crossLeft
 
 /**
  * Composes this stream with the specified stream to create a cartesian
- * product of elements, but keeps only elements from the other stream. The
- * `that` stream would be run multiple times, for every element in the `this`
+ * product of elements, but keeps only elements from the `right` stream. The
+ * `left` stream would be run multiple times, for every element in the `right`
  * stream.
  *
  * See also `Stream.zipRight` for the more common point-wise variant.
@@ -1065,14 +1065,14 @@ export const crossLeft: {
  * @category utils
  */
 export const crossRight: {
-  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>
+  <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AR, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AR, EL | ER, RL | RR>
 } = internal.crossRight
 
 /**
  * Composes this stream with the specified stream to create a cartesian
- * product of elements with a specified function. The `that` stream would be
- * run multiple times, for every element in the `this` stream.
+ * product of elements with a specified function. The `right` stream would be
+ * run multiple times, for every element in the `left` stream.
  *
  * See also `Stream.zipWith` for the more common point-wise variant.
  *
@@ -1080,15 +1080,15 @@ export const crossRight: {
  * @category utils
  */
 export const crossWith: {
-  <B, E2, R2, A, C>(
-    that: Stream<B, E2, R2>,
-    f: (a: A, b: B) => C
-  ): <E, R>(self: Stream<A, E, R>) => Stream<C, E2 | E, R2 | R>
-  <A, E, R, B, E2, R2, C>(
-    self: Stream<A, E, R>,
-    that: Stream<B, E2, R2>,
-    f: (a: A, b: B) => C
-  ): Stream<C, E | E2, R | R2>
+  <AR, ER, RR, AL, A>(
+    right: Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream<AL, EL, RL>,
+    right: Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream<A, EL | ER, RL | RR>
 } = internal.crossWith
 
 /**
@@ -5519,8 +5519,8 @@ export const zipAllWith: {
  * @category zipping
  */
 export const zipLatest: {
-  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>
+  <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<[AL, AR], EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<[AL, AR], EL | ER, RL | RR>
 } = internal.zipLatest
 
 /**
@@ -5575,20 +5575,20 @@ export const zipLatestAll: <T extends ReadonlyArray<Stream<any, any, any>>>(
  * @category zipping
  */
 export const zipLatestWith: {
-  <A2, E2, R2, A, A3>(
-    that: Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2, A3>(
-    self: Stream<A, E, R>,
-    that: Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ): Stream<A3, E | E2, R | R2>
+  <AR, ER, RR, AL, A>(
+    right: Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream<AL, EL, RL>,
+    right: Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream<A, EL | ER, RL | RR>
 } = internal.zipLatestWith
 
 /**
  * Zips this stream with another point-wise, but keeps only the outputs of
- * this stream.
+ * `left` stream.
  *
  * The new stream will end when one of the sides ends.
  *
@@ -5596,13 +5596,13 @@ export const zipLatestWith: {
  * @category zipping
  */
 export const zipLeft: {
-  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>
+  <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AL, ER | EL, RR | RL>
+  <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AL, EL | ER, RL | RR>
 } = internal.zipLeft
 
 /**
  * Zips this stream with another point-wise, but keeps only the outputs of the
- * other stream.
+ * `right` stream.
  *
  * The new stream will end when one of the sides ends.
  *
@@ -5610,8 +5610,8 @@ export const zipLeft: {
  * @category zipping
  */
 export const zipRight: {
-  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>
+  <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AR, ER | EL, RR | RL>
+  <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AR, EL | ER, RL | RR>
 } = internal.zipRight
 
 /**
@@ -5637,15 +5637,15 @@ export const zipRight: {
  * @category zipping
  */
 export const zipWith: {
-  <A2, E2, R2, A, A3>(
-    that: Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2, A3>(
-    self: Stream<A, E, R>,
-    that: Stream<A2, E2, R2>,
-    f: (a: A, a2: A2) => A3
-  ): Stream<A3, E | E2, R | R2>
+  <AR, ER, RR, AL, A>(
+    right: Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR, A>(
+    left: Stream<AL, EL, RL>,
+    right: Stream<AR, ER, RR>,
+    f: (left: AL, right: AR) => A
+  ): Stream<A, EL | ER, RL | RR>
 } = internal.zipWith
 
 /**

package/src/internal/configProvider.ts

@@ -329,7 +329,7 @@ const fromFlatLoop = <A>(
             core.flatMap((indices) => {
               if (indices.length === 0) {
                 return core.suspend(() =>
-                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), Arr.of)
+                  core.map(fromFlatLoop(flat, prefix, op.config, true), Arr.of)
                 ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
               }
               return pipe(

package/src/internal/metric/hook.ts

@@ -30,6 +30,7 @@ export const make = <In, Out>(
   options: {
     readonly get: LazyArg<Out>
     readonly update: (input: In) => void
+    readonly modify: (input: In) => void
   }
 ): MetricHook.MetricHook<In, Out> => ({
   [MetricHookTypeId]: metricHookVariance,
@@ -39,6 +40,23 @@ export const make = <In, Out>(
   ...options
 })
 
+/** @internal */
+export const onModify = dual<
+  <In, Out>(f: (input: In) => void) => (self: MetricHook.MetricHook<In, Out>) => MetricHook.MetricHook<In, Out>,
+  <In, Out>(self: MetricHook.MetricHook<In, Out>, f: (input: In) => void) => MetricHook.MetricHook<In, Out>
+>(2, (self, f) => ({
+  [MetricHookTypeId]: metricHookVariance,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  get: self.get,
+  update: self.update,
+  modify: (input) => {
+    self.modify(input)
+    return f(input)
+  }
+}))
+
 /** @internal */
 export const onUpdate = dual<
   <In, Out>(f: (input: In) => void) => (self: MetricHook.MetricHook<In, Out>) => MetricHook.MetricHook<In, Out>,
@@ -52,7 +70,8 @@ export const onUpdate = dual<
   update: (input) => {
     self.update(input)
     return f(input)
-  }
+  },
+  modify: self.modify
 }))
 
 const bigint0 = BigInt(0)
@@ -67,13 +86,15 @@ export const counter = <A extends (number | bigint)>(
       ? (value: A) => value >= bigint0
       : (value: A) => value >= 0
     : (_value: A) => true
+  const update = (value: A) => {
+    if (canUpdate(value)) {
+      sum = (sum as any) + value
+    }
+  }
   return make({
     get: () => metricState.counter(sum as number) as unknown as MetricState.MetricState.Counter<A>,
-    update: (value) => {
-      if (canUpdate(value)) {
-        sum = (sum as any) + value
-      }
-    }
+    update,
+    modify: update
   })
 }
 
@@ -89,7 +110,8 @@ export const frequency = (key: MetricKey.MetricKey.Frequency): MetricHook.Metric
   }
   return make({
     get: () => metricState.frequency(values),
-    update
+    update,
+    modify: update
   })
 }
 
@@ -106,6 +128,9 @@ export const gauge: {
     get: () => metricState.gauge(value as number) as unknown as MetricState.MetricState.Gauge<A>,
     update: (v) => {
       value = v
+    },
+    modify: (v) => {
+      value = (value as any) + v
     }
   })
 }
@@ -182,7 +207,8 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
         max,
         sum
       }),
-    update
+    update,
+    modify: update
   })
 }
 
@@ -258,7 +284,8 @@ export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook
         max,
         sum
       }),
-    update: ([value, timestamp]) => observe(value, timestamp)
+    update: ([value, timestamp]) => observe(value, timestamp),
+    modify: ([value, timestamp]) => observe(value, timestamp)
   })
 }
 

package/src/internal/metric/keyType.ts

@@ -117,10 +117,7 @@ class GaugeKeyType<A extends (number | bigint)> implements MetricKeyType.MetricK
   }
 }
 
-/**
- * @category model
- * @since 2.0.0
- */
+/** @internal */
 export class HistogramKeyType implements MetricKeyType.MetricKeyType.Histogram {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
   readonly [HistogramKeyTypeTypeId]: MetricKeyType.HistogramKeyTypeTypeId = HistogramKeyTypeTypeId
@@ -176,10 +173,7 @@ class SummaryKeyType implements MetricKeyType.MetricKeyType.Summary {
   }
 }
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const counter: <A extends number | bigint>(options?: {
   readonly bigint: boolean
   readonly incremental: boolean
@@ -189,18 +183,12 @@ export const counter: <A extends number | bigint>(options?: {
     options?.bigint ?? false
   )
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const frequency = (options?: {
   readonly preregisteredWords?: ReadonlyArray<string> | undefined
 }): MetricKeyType.MetricKeyType.Frequency => new FrequencyKeyType(options?.preregisteredWords ?? [])
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const gauge: <A extends number | bigint>(options?: {
   readonly bigint: boolean
 }) => GaugeKeyType<A> = (options) =>
@@ -208,18 +196,12 @@ export const gauge: <A extends number | bigint>(options?: {
     options?.bigint ?? false
   )
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const histogram = (boundaries: MetricBoundaries.MetricBoundaries): MetricKeyType.MetricKeyType.Histogram => {
   return new HistogramKeyType(boundaries)
 }
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const summary = (
   options: {
     readonly maxAge: Duration.DurationInput
@@ -231,44 +213,26 @@ export const summary = (
   return new SummaryKeyType(Duration.decode(options.maxAge), options.maxSize, options.error, options.quantiles)
 }
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isMetricKeyType = (u: unknown): u is MetricKeyType.MetricKeyType<unknown, unknown> =>
   hasProperty(u, MetricKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isCounterKey = (u: unknown): u is MetricKeyType.MetricKeyType.Counter<number | bigint> =>
   hasProperty(u, CounterKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isFrequencyKey = (u: unknown): u is MetricKeyType.MetricKeyType.Frequency =>
   hasProperty(u, FrequencyKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isGaugeKey = (u: unknown): u is MetricKeyType.MetricKeyType.Gauge<number | bigint> =>
   hasProperty(u, GaugeKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isHistogramKey = (u: unknown): u is MetricKeyType.MetricKeyType.Histogram =>
   hasProperty(u, HistogramKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isSummaryKey = (u: unknown): u is MetricKeyType.MetricKeyType.Summary =>
   hasProperty(u, SummaryKeyTypeTypeId)

package/src/internal/metric/polling.ts

@@ -56,7 +56,14 @@ export const collectAll = <R, E, Out>(
       (extraTags) =>
         Array.from(
           metrics.map((pollingMetric) => pollingMetric.metric.unsafeValue(extraTags))
-        )
+        ),
+      (inputs: Array<any>, extraTags) => {
+        for (let i = 0; i < inputs.length; i++) {
+          const pollingMetric = metrics[i]!
+          const input = pipe(inputs, (x) => x[i])
+          pollingMetric.metric.unsafeModify(input, extraTags)
+        }
+      }
     ),
     poll: core.forEachSequential(metrics, (metric) => metric.poll)
   }