@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/metric/key.ts

@@ -1,167 +0,0 @@
-import * as Arr from "../../Array.js"
-import type * as Duration from "../../Duration.js"
-import * as Equal from "../../Equal.js"
-import { dual, pipe } from "../../Function.js"
-import * as Hash from "../../Hash.js"
-import type * as MetricBoundaries from "../../MetricBoundaries.js"
-import type * as MetricKey from "../../MetricKey.js"
-import type * as MetricKeyType from "../../MetricKeyType.js"
-import type * as MetricLabel from "../../MetricLabel.js"
-import * as Option from "../../Option.js"
-import { pipeArguments } from "../../Pipeable.js"
-import { hasProperty } from "../../Predicate.js"
-import * as metricKeyType from "./keyType.js"
-import * as metricLabel from "./label.js"
-
-/** @internal */
-const MetricKeySymbolKey = "effect/MetricKey"
-
-/** @internal */
-export const MetricKeyTypeId: MetricKey.MetricKeyTypeId = Symbol.for(
-  MetricKeySymbolKey
-) as MetricKey.MetricKeyTypeId
-
-const metricKeyVariance = {
-  /* c8 ignore next */
-  _Type: (_: never) => _
-}
-
-const arrayEquivilence = Arr.getEquivalence(Equal.equals)
-
-/** @internal */
-class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
-  readonly [MetricKeyTypeId] = metricKeyVariance
-  constructor(
-    readonly name: string,
-    readonly keyType: Type,
-    readonly description: Option.Option<string>,
-    readonly tags: ReadonlyArray<MetricLabel.MetricLabel> = []
-  ) {
-    this._hash = pipe(
-      Hash.string(this.name + this.description),
-      Hash.combine(Hash.hash(this.keyType)),
-      Hash.combine(Hash.array(this.tags))
-    )
-  }
-  readonly _hash: number;
-  [Hash.symbol](): number {
-    return this._hash
-  }
-  [Equal.symbol](u: unknown): boolean {
-    return isMetricKey(u) &&
-      this.name === u.name &&
-      Equal.equals(this.keyType, u.keyType) &&
-      Equal.equals(this.description, u.description) &&
-      arrayEquivilence(this.tags, u.tags)
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export const isMetricKey = (u: unknown): u is MetricKey.MetricKey<MetricKeyType.MetricKeyType<unknown, unknown>> =>
-  hasProperty(u, MetricKeyTypeId)
-
-/** @internal */
-export const counter: {
-  (name: string, options?: {
-    readonly description?: string | undefined
-    readonly bigint?: false | undefined
-    readonly incremental?: boolean | undefined
-  }): MetricKey.MetricKey.Counter<number>
-  (name: string, options: {
-    readonly description?: string | undefined
-    readonly bigint: true
-    readonly incremental?: boolean | undefined
-  }): MetricKey.MetricKey.Counter<bigint>
-} = (name: string, options) =>
-  new MetricKeyImpl(
-    name,
-    metricKeyType.counter(options as any),
-    Option.fromNullable(options?.description)
-  )
-
-/** @internal */
-export const frequency = (name: string, options?: {
-  readonly description?: string | undefined
-  readonly preregisteredWords?: ReadonlyArray<string> | undefined
-}): MetricKey.MetricKey.Frequency =>
-  new MetricKeyImpl(name, metricKeyType.frequency(options), Option.fromNullable(options?.description))
-
-/** @internal */
-export const gauge: {
-  (name: string, options?: {
-    readonly description?: string | undefined
-    readonly bigint?: false | undefined
-  }): MetricKey.MetricKey.Gauge<number>
-  (name: string, options: {
-    readonly description?: string | undefined
-    readonly bigint: true
-  }): MetricKey.MetricKey.Gauge<bigint>
-} = (name, options) =>
-  new MetricKeyImpl(
-    name,
-    metricKeyType.gauge(options as any),
-    Option.fromNullable(options?.description)
-  )
-
-/** @internal */
-export const histogram = (
-  name: string,
-  boundaries: MetricBoundaries.MetricBoundaries,
-  description?: string
-): MetricKey.MetricKey.Histogram =>
-  new MetricKeyImpl(
-    name,
-    metricKeyType.histogram(boundaries),
-    Option.fromNullable(description)
-  )
-
-/** @internal */
-export const summary = (
-  options: {
-    readonly name: string
-    readonly maxAge: Duration.DurationInput
-    readonly maxSize: number
-    readonly error: number
-    readonly quantiles: ReadonlyArray<number>
-    readonly description?: string | undefined
-  }
-): MetricKey.MetricKey.Summary =>
-  new MetricKeyImpl(
-    options.name,
-    metricKeyType.summary(options),
-    Option.fromNullable(options.description)
-  )
-
-/** @internal */
-export const tagged = dual<
-  (
-    key: string,
-    value: string
-  ) => <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey.MetricKey<Type>
-  ) => MetricKey.MetricKey<Type>,
-  <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey.MetricKey<Type>,
-    key: string,
-    value: string
-  ) => MetricKey.MetricKey<Type>
->(3, (self, key, value) => taggedWithLabels(self, [metricLabel.make(key, value)]))
-
-/** @internal */
-export const taggedWithLabels = dual<
-  (
-    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
-  ) => <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey.MetricKey<Type>
-  ) => MetricKey.MetricKey<Type>,
-  <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey.MetricKey<Type>,
-    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
-  ) => MetricKey.MetricKey<Type>
->(2, (self, extraTags) =>
-  extraTags.length === 0
-    ? self
-    : new MetricKeyImpl(self.name, self.keyType, self.description, Arr.union(self.tags, extraTags)))

package/src/internal/metric/keyType.ts

@@ -1,238 +0,0 @@
-import * as Duration from "../../Duration.js"
-import * as Equal from "../../Equal.js"
-import { pipe } from "../../Function.js"
-import * as Hash from "../../Hash.js"
-import type * as MetricBoundaries from "../../MetricBoundaries.js"
-import type * as MetricKeyType from "../../MetricKeyType.js"
-import { pipeArguments } from "../../Pipeable.js"
-import { hasProperty } from "../../Predicate.js"
-
-/** @internal */
-const MetricKeyTypeSymbolKey = "effect/MetricKeyType"
-
-/** @internal */
-export const MetricKeyTypeTypeId: MetricKeyType.MetricKeyTypeTypeId = Symbol.for(
-  MetricKeyTypeSymbolKey
-) as MetricKeyType.MetricKeyTypeTypeId
-
-/** @internal */
-const CounterKeyTypeSymbolKey = "effect/MetricKeyType/Counter"
-
-/** @internal */
-export const CounterKeyTypeTypeId: MetricKeyType.CounterKeyTypeTypeId = Symbol.for(
-  CounterKeyTypeSymbolKey
-) as MetricKeyType.CounterKeyTypeTypeId
-
-/** @internal */
-const FrequencyKeyTypeSymbolKey = "effect/MetricKeyType/Frequency"
-
-/** @internal */
-export const FrequencyKeyTypeTypeId: MetricKeyType.FrequencyKeyTypeTypeId = Symbol.for(
-  FrequencyKeyTypeSymbolKey
-) as MetricKeyType.FrequencyKeyTypeTypeId
-
-/** @internal */
-const GaugeKeyTypeSymbolKey = "effect/MetricKeyType/Gauge"
-
-/** @internal */
-export const GaugeKeyTypeTypeId: MetricKeyType.GaugeKeyTypeTypeId = Symbol.for(
-  GaugeKeyTypeSymbolKey
-) as MetricKeyType.GaugeKeyTypeTypeId
-
-/** @internal */
-const HistogramKeyTypeSymbolKey = "effect/MetricKeyType/Histogram"
-
-/** @internal */
-export const HistogramKeyTypeTypeId: MetricKeyType.HistogramKeyTypeTypeId = Symbol.for(
-  HistogramKeyTypeSymbolKey
-) as MetricKeyType.HistogramKeyTypeTypeId
-
-/** @internal */
-const SummaryKeyTypeSymbolKey = "effect/MetricKeyType/Summary"
-
-/** @internal */
-export const SummaryKeyTypeTypeId: MetricKeyType.SummaryKeyTypeTypeId = Symbol.for(
-  SummaryKeyTypeSymbolKey
-) as MetricKeyType.SummaryKeyTypeTypeId
-
-const metricKeyTypeVariance = {
-  /* c8 ignore next */
-  _In: (_: unknown) => _,
-  /* c8 ignore next */
-  _Out: (_: never) => _
-}
-
-/** @internal */
-class CounterKeyType<A extends (number | bigint)> implements MetricKeyType.MetricKeyType.Counter<A> {
-  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [CounterKeyTypeTypeId]: MetricKeyType.CounterKeyTypeTypeId = CounterKeyTypeTypeId
-  constructor(readonly incremental: boolean, readonly bigint: boolean) {
-    this._hash = Hash.string(CounterKeyTypeSymbolKey)
-  }
-  readonly _hash: number;
-  [Hash.symbol](): number {
-    return this._hash
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isCounterKey(that)
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-const FrequencyKeyTypeHash = Hash.string(FrequencyKeyTypeSymbolKey)
-
-/** @internal */
-class FrequencyKeyType implements MetricKeyType.MetricKeyType.Frequency {
-  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId
-  constructor(readonly preregisteredWords: ReadonlyArray<string>) {}
-  [Hash.symbol](): number {
-    return FrequencyKeyTypeHash
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isFrequencyKey(that)
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-const GaugeKeyTypeHash = Hash.string(GaugeKeyTypeSymbolKey)
-
-/** @internal */
-class GaugeKeyType<A extends (number | bigint)> implements MetricKeyType.MetricKeyType.Gauge<A> {
-  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [GaugeKeyTypeTypeId]: MetricKeyType.GaugeKeyTypeTypeId = GaugeKeyTypeTypeId
-  constructor(readonly bigint: boolean) {}
-  [Hash.symbol](): number {
-    return GaugeKeyTypeHash
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isGaugeKey(that)
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export class HistogramKeyType implements MetricKeyType.MetricKeyType.Histogram {
-  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [HistogramKeyTypeTypeId]: MetricKeyType.HistogramKeyTypeTypeId = HistogramKeyTypeTypeId
-  constructor(readonly boundaries: MetricBoundaries.MetricBoundaries) {
-    this._hash = pipe(
-      Hash.string(HistogramKeyTypeSymbolKey),
-      Hash.combine(Hash.hash(this.boundaries))
-    )
-  }
-  readonly _hash: number;
-  [Hash.symbol](): number {
-    return this._hash
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isHistogramKey(that) && Equal.equals(this.boundaries, that.boundaries)
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-class SummaryKeyType implements MetricKeyType.MetricKeyType.Summary {
-  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [SummaryKeyTypeTypeId]: MetricKeyType.SummaryKeyTypeTypeId = SummaryKeyTypeTypeId
-  constructor(
-    readonly maxAge: Duration.Duration,
-    readonly maxSize: number,
-    readonly error: number,
-    readonly quantiles: ReadonlyArray<number>
-  ) {
-    this._hash = pipe(
-      Hash.string(SummaryKeyTypeSymbolKey),
-      Hash.combine(Hash.hash(this.maxAge)),
-      Hash.combine(Hash.hash(this.maxSize)),
-      Hash.combine(Hash.hash(this.error)),
-      Hash.combine(Hash.array(this.quantiles))
-    )
-  }
-  readonly _hash: number;
-  [Hash.symbol](): number {
-    return this._hash
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isSummaryKey(that) &&
-      Equal.equals(this.maxAge, that.maxAge) &&
-      this.maxSize === that.maxSize &&
-      this.error === that.error &&
-      Equal.equals(this.quantiles, that.quantiles)
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export const counter: <A extends number | bigint>(options?: {
-  readonly bigint: boolean
-  readonly incremental: boolean
-}) => CounterKeyType<A> = (options) =>
-  new CounterKeyType(
-    options?.incremental ?? false,
-    options?.bigint ?? false
-  )
-
-/** @internal */
-export const frequency = (options?: {
-  readonly preregisteredWords?: ReadonlyArray<string> | undefined
-}): MetricKeyType.MetricKeyType.Frequency => new FrequencyKeyType(options?.preregisteredWords ?? [])
-
-/** @internal */
-export const gauge: <A extends number | bigint>(options?: {
-  readonly bigint: boolean
-}) => GaugeKeyType<A> = (options) =>
-  new GaugeKeyType(
-    options?.bigint ?? false
-  )
-
-/** @internal */
-export const histogram = (boundaries: MetricBoundaries.MetricBoundaries): MetricKeyType.MetricKeyType.Histogram => {
-  return new HistogramKeyType(boundaries)
-}
-
-/** @internal */
-export const summary = (
-  options: {
-    readonly maxAge: Duration.DurationInput
-    readonly maxSize: number
-    readonly error: number
-    readonly quantiles: ReadonlyArray<number>
-  }
-): MetricKeyType.MetricKeyType.Summary => {
-  return new SummaryKeyType(Duration.decode(options.maxAge), options.maxSize, options.error, options.quantiles)
-}
-
-/** @internal */
-export const isMetricKeyType = (u: unknown): u is MetricKeyType.MetricKeyType<unknown, unknown> =>
-  hasProperty(u, MetricKeyTypeTypeId)
-
-/** @internal */
-export const isCounterKey = (u: unknown): u is MetricKeyType.MetricKeyType.Counter<number | bigint> =>
-  hasProperty(u, CounterKeyTypeTypeId)
-
-/** @internal */
-export const isFrequencyKey = (u: unknown): u is MetricKeyType.MetricKeyType.Frequency =>
-  hasProperty(u, FrequencyKeyTypeTypeId)
-
-/** @internal */
-export const isGaugeKey = (u: unknown): u is MetricKeyType.MetricKeyType.Gauge<number | bigint> =>
-  hasProperty(u, GaugeKeyTypeTypeId)
-
-/** @internal */
-export const isHistogramKey = (u: unknown): u is MetricKeyType.MetricKeyType.Histogram =>
-  hasProperty(u, HistogramKeyTypeTypeId)
-
-/** @internal */
-export const isSummaryKey = (u: unknown): u is MetricKeyType.MetricKeyType.Summary =>
-  hasProperty(u, SummaryKeyTypeTypeId)

package/src/internal/metric/label.ts

@@ -1,41 +0,0 @@
-import * as Equal from "../../Equal.js"
-import * as Hash from "../../Hash.js"
-import type * as MetricLabel from "../../MetricLabel.js"
-import { pipeArguments } from "../../Pipeable.js"
-import { hasProperty } from "../../Predicate.js"
-
-/** @internal */
-const MetricLabelSymbolKey = "effect/MetricLabel"
-
-/** @internal */
-export const MetricLabelTypeId: MetricLabel.MetricLabelTypeId = Symbol.for(
-  MetricLabelSymbolKey
-) as MetricLabel.MetricLabelTypeId
-
-/** @internal */
-class MetricLabelImpl implements MetricLabel.MetricLabel {
-  readonly [MetricLabelTypeId]: MetricLabel.MetricLabelTypeId = MetricLabelTypeId
-  readonly _hash: number
-  constructor(readonly key: string, readonly value: string) {
-    this._hash = Hash.string(MetricLabelSymbolKey + this.key + this.value)
-  }
-  [Hash.symbol](): number {
-    return this._hash
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isMetricLabel(that) &&
-      this.key === that.key &&
-      this.value === that.value
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export const make = (key: string, value: string): MetricLabel.MetricLabel => {
-  return new MetricLabelImpl(key, value)
-}
-
-/** @internal */
-export const isMetricLabel = (u: unknown): u is MetricLabel.MetricLabel => hasProperty(u, MetricLabelTypeId)

package/src/internal/metric/pair.ts

@@ -1,48 +0,0 @@
-import type * as MetricKey from "../../MetricKey.js"
-import type * as MetricKeyType from "../../MetricKeyType.js"
-import type * as MetricPair from "../../MetricPair.js"
-import type * as MetricState from "../../MetricState.js"
-import { pipeArguments } from "../../Pipeable.js"
-
-/** @internal */
-const MetricPairSymbolKey = "effect/MetricPair"
-
-/** @internal */
-export const MetricPairTypeId: MetricPair.MetricPairTypeId = Symbol.for(
-  MetricPairSymbolKey
-) as MetricPair.MetricPairTypeId
-
-const metricPairVariance = {
-  /* c8 ignore next */
-  _Type: (_: never) => _
-}
-
-/** @internal */
-export const make = <Type extends MetricKeyType.MetricKeyType<any, any>>(
-  metricKey: MetricKey.MetricKey<Type>,
-  metricState: MetricState.MetricState<MetricKeyType.MetricKeyType.OutType<Type>>
-): MetricPair.MetricPair.Untyped => {
-  return {
-    [MetricPairTypeId]: metricPairVariance,
-    metricKey,
-    metricState,
-    pipe() {
-      return pipeArguments(this, arguments)
-    }
-  }
-}
-
-/** @internal */
-export const unsafeMake = <Type extends MetricKeyType.MetricKeyType<any, any>>(
-  metricKey: MetricKey.MetricKey<Type>,
-  metricState: MetricState.MetricState.Untyped
-): MetricPair.MetricPair.Untyped => {
-  return {
-    [MetricPairTypeId]: metricPairVariance,
-    metricKey,
-    metricState,
-    pipe() {
-      return pipeArguments(this, arguments)
-    }
-  }
-}

package/src/internal/metric/polling.ts

@@ -1,149 +0,0 @@
-import type * as Effect from "../../Effect.js"
-import type * as Fiber from "../../Fiber.js"
-import { dual, pipe } from "../../Function.js"
-import type * as Metric from "../../Metric.js"
-import type * as MetricPolling from "../../MetricPolling.js"
-import { pipeArguments } from "../../Pipeable.js"
-import type * as Schedule from "../../Schedule.js"
-import type * as Scope from "../../Scope.js"
-import * as core from "../core.js"
-import * as metric from "../metric.js"
-import * as schedule_ from "../schedule.js"
-
-/** @internal */
-const MetricPollingSymbolKey = "effect/MetricPolling"
-
-/** @internal */
-export const MetricPollingTypeId: MetricPolling.MetricPollingTypeId = Symbol.for(
-  MetricPollingSymbolKey
-) as MetricPolling.MetricPollingTypeId
-
-/** @internal */
-export const make = <Type, In, Out, R, E>(
-  metric: Metric.Metric<Type, In, Out>,
-  poll: Effect.Effect<In, E, R>
-): MetricPolling.MetricPolling<Type, In, R, E, Out> => {
-  return {
-    [MetricPollingTypeId]: MetricPollingTypeId,
-    pipe() {
-      return pipeArguments(this, arguments)
-    },
-    metric,
-    poll
-  }
-}
-
-/** @internal */
-export const collectAll = <R, E, Out>(
-  iterable: Iterable<MetricPolling.MetricPolling<any, any, R, E, Out>>
-): MetricPolling.MetricPolling<Array<any>, Array<any>, R, E, Array<Out>> => {
-  const metrics = Array.from(iterable)
-  return {
-    [MetricPollingTypeId]: MetricPollingTypeId,
-    pipe() {
-      return pipeArguments(this, arguments)
-    },
-    metric: metric.make(
-      Array.of<any>(void 0) as Array<any>,
-      (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.unsafeUpdate(input, extraTags)
-        }
-      },
-      (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)
-  }
-}
-
-/** @internal */
-export const launch = dual<
-  <A2, R2>(
-    schedule: Schedule.Schedule<A2, unknown, R2>
-  ) => <Type, In, R, E, Out>(
-    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>,
-  <Type, In, R, E, Out, A2, R2>(
-    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    schedule: Schedule.Schedule<A2, unknown, R2>
-  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>
->(2, (self, schedule) =>
-  pipe(
-    pollAndUpdate(self),
-    core.zipRight(metric.value(self.metric)),
-    schedule_.scheduleForked(schedule)
-  ))
-
-/** @internal */
-export const poll = <Type, In, R, E, Out>(
-  self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-): Effect.Effect<In, E, R> => self.poll
-
-/** @internal */
-export const pollAndUpdate = <Type, In, R, E, Out>(
-  self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-): Effect.Effect<void, E, R> => core.flatMap(self.poll, (value) => metric.update(self.metric, value))
-
-/** @internal */
-export const retry = dual<
-  <X, E, R2>(
-    policy: Schedule.Schedule<X, E, R2>
-  ) => <Type, In, R, Out>(
-    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-  ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>,
-  <Type, In, R, E, Out, X, R2>(
-    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    policy: Schedule.Schedule<X, E, R2>
-  ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>
->(2, (self, policy) => ({
-  [MetricPollingTypeId]: MetricPollingTypeId,
-  pipe() {
-    return pipeArguments(this, arguments)
-  },
-  metric: self.metric,
-  poll: schedule_.retry_Effect(self.poll, policy)
-}))
-
-/** @internal */
-export const zip = dual<
-  <Type2, In2, R2, E2, Out2>(
-    that: MetricPolling.MetricPolling<Type2, In2, R2, E2, Out2>
-  ) => <Type, In, R, E, Out>(
-    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-  ) => MetricPolling.MetricPolling<
-    readonly [Type, Type2],
-    readonly [In, In2],
-    R | R2,
-    E | E2,
-    [Out, Out2]
-  >,
-  <Type, In, R, E, Out, Type2, In2, R2, E2, Out2>(
-    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    that: MetricPolling.MetricPolling<Type2, In2, R2, E2, Out2>
-  ) => MetricPolling.MetricPolling<
-    readonly [Type, Type2],
-    readonly [In, In2],
-    R | R2,
-    E | E2,
-    [Out, Out2]
-  >
->(2, (self, that) => ({
-  [MetricPollingTypeId]: MetricPollingTypeId,
-  pipe() {
-    return pipeArguments(this, arguments)
-  },
-  metric: pipe(self.metric, metric.zip(that.metric)),
-  poll: core.zip(self.poll, that.poll)
-}))