effect 3.15.5 → 3.16.1

package/src/Effect.ts

@@ -12,6 +12,7 @@ import type * as Deferred from "./Deferred.js"
 import type * as Duration from "./Duration.js"
 import type * as Either from "./Either.js"
 import type { Equivalence } from "./Equivalence.js"
+import type { ExecutionPlan } from "./ExecutionPlan.js"
 import type { ExecutionStrategy } from "./ExecutionStrategy.js"
 import type * as Exit from "./Exit.js"
 import type * as Fiber from "./Fiber.js"
@@ -32,6 +33,7 @@ import * as effect from "./internal/core-effect.js"
 import * as core from "./internal/core.js"
 import * as defaultServices from "./internal/defaultServices.js"
 import * as circular from "./internal/effect/circular.js"
+import * as internalExecutionPlan from "./internal/executionPlan.js"
 import * as fiberRuntime from "./internal/fiberRuntime.js"
 import * as layer from "./internal/layer.js"
 import * as option_ from "./internal/option.js"
@@ -8120,9 +8122,7 @@ export const retry: {
    * @since 2.0.0
    * @category Error handling
    */
-  <E, O extends NoExcessProperties<Retry.Options<E>, O>>(options: O): <A, R>(
-    self: Effect<A, E, R>
-  ) => Retry.Return<R, E, A, O>
+  <E, O extends NoExcessProperties<Retry.Options<E>, O>>(options: O): <A, R>(self: Effect<A, E, R>) => Retry.Return<R, E, A, O>
   /**
    * Retries a failing effect based on a defined retry policy.
    *
@@ -8479,9 +8479,43 @@ export const retry: {
    * @since 2.0.0
    * @category Error handling
    */
-  <A, E, R, B, R1>(self: Effect<A, E, R>, policy: Schedule.Schedule<B, E, R1>): Effect<A, E, R1 | R>
+  <A, E, R, B, R1>(self: Effect<A, E, R>, policy: Schedule.Schedule<B, NoInfer<E>, R1>): Effect<A, E, R1 | R>
 } = schedule_.retry_combined
 
+/**
+ * Apply an `ExecutionPlan` to the effect, which allows you to fallback to
+ * different resources in case of failure.
+ *
+ * @since 3.16.0
+ * @category Error handling
+ * @experimental
+ */
+export const withExecutionPlan: {
+  /**
+   * Apply an `ExecutionPlan` to the effect, which allows you to fallback to
+   * different resources in case of failure.
+   *
+   * @since 3.16.0
+   * @category Error handling
+   * @experimental
+   */
+  <Input, Provides, PlanE, PlanR>(
+    plan: ExecutionPlan<{ provides: Provides; input: Input; error: PlanE; requirements: PlanR }>
+  ): <A, E extends Input, R>(effect: Effect<A, E, R>) => Effect<A, E | PlanE, Exclude<R, Provides> | PlanR>
+  /**
+   * Apply an `ExecutionPlan` to the effect, which allows you to fallback to
+   * different resources in case of failure.
+   *
+   * @since 3.16.0
+   * @category Error handling
+   * @experimental
+   */
+  <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+    effect: Effect<A, E, R>,
+    plan: ExecutionPlan<{ provides: Provides; input: Input; error: PlanE; requirements: PlanR }>
+  ): Effect<A, E | PlanE, Exclude<R, Provides> | PlanR>
+} = internalExecutionPlan.withExecutionPlan
+
 /**
  * Retries a failing effect and runs a fallback effect if retries are exhausted.
  *
@@ -22271,7 +22305,7 @@ export const scheduleForked: {
    * @category Repetition / Recursion
    */
   <A, E, R, Out, R2>(self: Effect<A, E, R>, schedule: Schedule.Schedule<Out, unknown, R2>): Effect<Fiber.RuntimeFiber<Out, E>, never, Scope.Scope | R | R2>
-} = circular.scheduleForked
+} = schedule_.scheduleForked
 
 /**
  * Runs an effect repeatedly according to a schedule, starting from a specified
@@ -27762,14 +27796,18 @@ export const Service: <Self = never>() => [Self] extends [never] ? MissingSelfGe
     const Key extends string,
     const Make extends
       | {
-        readonly scoped: Effect<Service.AllowedType<Key, Make>, any, any>
+        readonly scoped:
+          | Effect<Service.AllowedType<Key, Make>, any, any>
+          | ((...args: any) => Effect<Service.AllowedType<Key, Make>, any, any>)
         readonly dependencies?: ReadonlyArray<Layer.Layer.Any>
         readonly accessors?: boolean
         /** @deprecated */
         readonly ಠ_ಠ: never
       }
       | {
-        readonly effect: Effect<Service.AllowedType<Key, Make>, any, any>
+        readonly effect:
+          | Effect<Service.AllowedType<Key, Make>, any, any>
+          | ((...args: any) => Effect<Service.AllowedType<Key, Make>, any, any>)
         readonly dependencies?: ReadonlyArray<Layer.Layer.Any>
         readonly accessors?: boolean
         /** @deprecated */
@@ -27796,7 +27834,9 @@ export const Service: <Self = never>() => [Self] extends [never] ? MissingSelfGe
   <
     const Key extends string,
     const Make extends NoExcessProperties<{
-      readonly scoped: Effect<Service.AllowedType<Key, Make>, any, any>
+      readonly scoped:
+        | Effect<Service.AllowedType<Key, Make>, any, any>
+        | ((...args: any) => Effect<Service.AllowedType<Key, Make>, any, any>)
       readonly dependencies?: ReadonlyArray<Layer.Layer.Any>
       readonly accessors?: boolean
     }, Make>
@@ -27807,7 +27847,9 @@ export const Service: <Self = never>() => [Self] extends [never] ? MissingSelfGe
   <
     const Key extends string,
     const Make extends NoExcessProperties<{
-      readonly effect: Effect<Service.AllowedType<Key, Make>, any, any>
+      readonly effect:
+        | Effect<Service.AllowedType<Key, Make>, any, any>
+        | ((...args: any) => Effect<Service.AllowedType<Key, Make>, any, any>)
       readonly dependencies?: ReadonlyArray<Layer.Layer.Any>
       readonly accessors?: boolean
     }, Make>
@@ -27890,15 +27932,28 @@ export const Service: <Self = never>() => [Self] extends [never] ? MissingSelfGe
     const hasDeps = "dependencies" in maker && maker.dependencies.length > 0
     const layerName = hasDeps ? "DefaultWithoutDependencies" : "Default"
     let layerCache: Layer.Layer.Any | undefined
+    let isFunction = false
     if ("effect" in maker) {
+      isFunction = typeof maker.effect === "function"
       Object.defineProperty(TagClass, layerName, {
         get(this: any) {
+          if (isFunction) {
+            return function(this: typeof TagClass) {
+              return layer.fromEffect(TagClass, map(maker.effect.apply(null, arguments), (_) => new this(_)))
+            }.bind(this)
+          }
           return layerCache ??= layer.fromEffect(TagClass, map(maker.effect, (_) => new this(_)))
         }
       })
     } else if ("scoped" in maker) {
+      isFunction = typeof maker.scoped === "function"
       Object.defineProperty(TagClass, layerName, {
         get(this: any) {
+          if (isFunction) {
+            return function(this: typeof TagClass) {
+              return layer.scoped(TagClass, map(maker.scoped.apply(null, arguments), (_) => new this(_)))
+            }.bind(this)
+          }
           return layerCache ??= layer.scoped(TagClass, map(maker.scoped, (_) => new this(_)))
         }
       })
@@ -27920,6 +27975,14 @@ export const Service: <Self = never>() => [Self] extends [never] ? MissingSelfGe
       let layerWithDepsCache: Layer.Layer.Any | undefined
       Object.defineProperty(TagClass, "Default", {
         get(this: any) {
+          if (isFunction) {
+            return function(this: typeof TagClass) {
+              return layer.provide(
+                this.DefaultWithoutDependencies.apply(null, arguments),
+                maker.dependencies
+              )
+            }
+          }
           return layerWithDepsCache ??= layer.provide(
             this.DefaultWithoutDependencies,
             maker.dependencies
@@ -27992,16 +28055,27 @@ export declare namespace Service {
     & { key: Key }
     & (MakeAccessors<Make> extends true ? Tag.Proxy<Self, MakeService<Make>> : {})
     & (MakeDeps<Make> extends never ? {
-        readonly Default: Layer.Layer<Self, MakeError<Make>, MakeContext<Make>>
+        readonly Default: HasArguments<Make> extends true ?
+          (...args: MakeArguments<Make>) => Layer.Layer<Self, MakeError<Make>, MakeContext<Make>>
+          : Layer.Layer<Self, MakeError<Make>, MakeContext<Make>>
       } :
       {
-        readonly DefaultWithoutDependencies: Layer.Layer<Self, MakeError<Make>, MakeContext<Make>>
-        readonly Default: Layer.Layer<
-          Self,
-          MakeError<Make> | MakeDepsE<Make>,
-          | Exclude<MakeContext<Make>, MakeDepsOut<Make>>
-          | MakeDepsIn<Make>
-        >
+        readonly DefaultWithoutDependencies: HasArguments<Make> extends true
+          ? (...args: MakeArguments<Make>) => Layer.Layer<Self, MakeError<Make>, MakeContext<Make>>
+          : Layer.Layer<Self, MakeError<Make>, MakeContext<Make>>
+
+        readonly Default: HasArguments<Make> extends true ? (...args: MakeArguments<Make>) => Layer.Layer<
+            Self,
+            MakeError<Make> | MakeDepsE<Make>,
+            | Exclude<MakeContext<Make>, MakeDepsOut<Make>>
+            | MakeDepsIn<Make>
+          > :
+          Layer.Layer<
+            Self,
+            MakeError<Make> | MakeDepsE<Make>,
+            | Exclude<MakeContext<Make>, MakeDepsOut<Make>>
+            | MakeDepsIn<Make>
+          >
       })
 
   /**
@@ -28009,6 +28083,8 @@ export declare namespace Service {
    */
   export type MakeService<Make> = Make extends { readonly effect: Effect<infer _A, infer _E, infer _R> } ? _A
     : Make extends { readonly scoped: Effect<infer _A, infer _E, infer _R> } ? _A
+    : Make extends { readonly effect: (...args: infer _Args) => Effect<infer _A, infer _E, infer _R> } ? _A
+    : Make extends { readonly scoped: (...args: infer _Args) => Effect<infer _A, infer _E, infer _R> } ? _A
     : Make extends { readonly sync: LazyArg<infer A> } ? A
     : Make extends { readonly succeed: infer A } ? A
     : never
@@ -28018,6 +28094,8 @@ export declare namespace Service {
    */
   export type MakeError<Make> = Make extends { readonly effect: Effect<infer _A, infer _E, infer _R> } ? _E
     : Make extends { readonly scoped: Effect<infer _A, infer _E, infer _R> } ? _E
+    : Make extends { readonly effect: (...args: infer _Args) => Effect<infer _A, infer _E, infer _R> } ? _E
+    : Make extends { readonly scoped: (...args: infer _Args) => Effect<infer _A, infer _E, infer _R> } ? _E
     : never
 
   /**
@@ -28025,6 +28103,9 @@ export declare namespace Service {
    */
   export type MakeContext<Make> = Make extends { readonly effect: Effect<infer _A, infer _E, infer _R> } ? _R
     : Make extends { readonly scoped: Effect<infer _A, infer _E, infer _R> } ? Exclude<_R, Scope.Scope>
+    : Make extends { readonly effect: (...args: infer _Args) => Effect<infer _A, infer _E, infer _R> } ? _R
+    : Make extends { readonly scoped: (...args: infer _Args) => Effect<infer _A, infer _E, infer _R> } ?
+      Exclude<_R, Scope.Scope>
     : never
 
   /**
@@ -28054,6 +28135,25 @@ export declare namespace Service {
    */
   export type MakeAccessors<Make> = Make extends { readonly accessors: true } ? true
     : false
+
+  /**
+   * @since 3.16.0
+   */
+  export type MakeArguments<Make> = Make extends
+    { readonly effect: (...args: infer Args) => Effect<infer _A, infer _E, infer _R> } ? Args
+    : Make extends { readonly scoped: (...args: infer Args) => Effect<infer _A, infer _E, infer _R> } ? Args
+    : never
+
+  /**
+   * @since 3.16.0
+   */
+  export type HasArguments<Make> = Make extends {
+    readonly scoped: (...args: ReadonlyArray<any>) => Effect<infer _A, infer _E, infer _R>
+  } ? true :
+    Make extends {
+      readonly effect: (...args: ReadonlyArray<any>) => Effect<infer _A, infer _E, infer _R>
+    } ? true :
+    false
 }
 
 /**

package/src/ExecutionPlan.ts

@@ -0,0 +1,308 @@
+/**
+ * @since 3.16.0
+ * @experimental
+ */
+import type { NonEmptyReadonlyArray } from "./Array.js"
+import type * as Context from "./Context.js"
+import * as Effect from "./Effect.js"
+import * as internal from "./internal/executionPlan.js"
+import * as Layer from "./Layer.js"
+import type { Pipeable } from "./Pipeable.js"
+import { pipeArguments } from "./Pipeable.js"
+import type * as Schedule from "./Schedule.js"
+
+/**
+ * @since 3.16.0
+ * @category Symbols
+ * @experimental
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 3.16.0
+ * @category Symbols
+ * @experimental
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 3.16.0
+ * @category Guards
+ * @experimental
+ */
+export const isExecutionPlan: (u: unknown) => u is ExecutionPlan<any> = internal.isExecutionPlan
+
+/**
+ * A `ExecutionPlan` can be used with `Effect.withExecutionPlan` or `Stream.withExecutionPlan`, allowing you to provide different resources for each step of execution until the effect succeeds or the plan is exhausted.
+ *
+ * ```ts
+ * import { type AiLanguageModel } from "@effect/ai"
+ * import type { Layer } from "effect"
+ * import { Effect, ExecutionPlan, Schedule } from "effect"
+ *
+ * declare const layerBad: Layer.Layer<AiLanguageModel.AiLanguageModel>
+ * declare const layerGood: Layer.Layer<AiLanguageModel.AiLanguageModel>
+ *
+ * const ThePlan = ExecutionPlan.make(
+ *   {
+ *     // First try with the bad layer 2 times with a 3 second delay between attempts
+ *     provide: layerBad,
+ *     attempts: 2,
+ *     schedule: Schedule.spaced(3000)
+ *   },
+ *   // Then try with the bad layer 3 times with a 1 second delay between attempts
+ *   {
+ *     provide: layerBad,
+ *     attempts: 3,
+ *     schedule: Schedule.spaced(1000)
+ *   },
+ *   // Finally try with the good layer.
+ *   //
+ *   // If `attempts` is omitted, the plan will only attempt once, unless a schedule is provided.
+ *   {
+ *     provide: layerGood
+ *   }
+ * )
+ *
+ * declare const effect: Effect.Effect<
+ *   void,
+ *   never,
+ *   AiLanguageModel.AiLanguageModel
+ * >
+ * const withPlan: Effect.Effect<void> = Effect.withExecutionPlan(effect, ThePlan)
+ * ```
+ *
+ * @since 3.16.0
+ * @category Models
+ * @experimental
+ */
+export interface ExecutionPlan<
+  Types extends {
+    provides: any
+    input: any
+    error: any
+    requirements: any
+  }
+> extends Pipeable {
+  readonly [TypeId]: TypeId
+  readonly steps: NonEmptyReadonlyArray<{
+    readonly provide:
+      | Context.Context<Types["provides"]>
+      | Layer.Layer<Types["provides"], Types["error"], Types["requirements"]>
+    readonly attempts?: number | undefined
+    readonly while?:
+      | ((input: Types["input"]) => Effect.Effect<boolean, Types["error"], Types["requirements"]>)
+      | undefined
+    readonly schedule?: Schedule.Schedule<any, Types["input"], Types["requirements"]> | undefined
+  }>
+
+  /**
+   * Returns an equivalent `ExecutionPlan` with the requirements satisfied,
+   * using the current context.
+   */
+  readonly withRequirements: Effect.Effect<
+    ExecutionPlan<{
+      provides: Types["provides"]
+      input: Types["input"]
+      error: Types["error"]
+      requirements: never
+    }>,
+    never,
+    Types["requirements"]
+  >
+}
+
+/**
+ * @since 3.16.0
+ * @experimental
+ */
+export type TypesBase = {
+  provides: any
+  input: any
+  error: any
+  requirements: any
+}
+
+/**
+ * Create an `ExecutionPlan`, which can be used with `Effect.withExecutionPlan` or `Stream.withExecutionPlan`, allowing you to provide different resources for each step of execution until the effect succeeds or the plan is exhausted.
+ *
+ * ```ts
+ * import { type AiLanguageModel } from "@effect/ai"
+ * import type { Layer } from "effect"
+ * import { Effect, ExecutionPlan, Schedule } from "effect"
+ *
+ * declare const layerBad: Layer.Layer<AiLanguageModel.AiLanguageModel>
+ * declare const layerGood: Layer.Layer<AiLanguageModel.AiLanguageModel>
+ *
+ * const ThePlan = ExecutionPlan.make(
+ *   {
+ *     // First try with the bad layer 2 times with a 3 second delay between attempts
+ *     provide: layerBad,
+ *     attempts: 2,
+ *     schedule: Schedule.spaced(3000)
+ *   },
+ *   // Then try with the bad layer 3 times with a 1 second delay between attempts
+ *   {
+ *     provide: layerBad,
+ *     attempts: 3,
+ *     schedule: Schedule.spaced(1000)
+ *   },
+ *   // Finally try with the good layer.
+ *   //
+ *   // If `attempts` is omitted, the plan will only attempt once, unless a schedule is provided.
+ *   {
+ *     provide: layerGood
+ *   }
+ * )
+ *
+ * declare const effect: Effect.Effect<
+ *   void,
+ *   never,
+ *   AiLanguageModel.AiLanguageModel
+ * >
+ * const withPlan: Effect.Effect<void> = Effect.withExecutionPlan(effect, ThePlan)
+ * ```
+ *
+ * @since 3.16.0
+ * @category Constructors
+ * @experimental
+ */
+export const make = <const Steps extends NonEmptyReadonlyArray<make.Step>>(
+  ...steps: Steps & { [K in keyof Steps]: make.Step }
+): ExecutionPlan<{
+  provides: make.StepProvides<Steps>
+  input: make.StepInput<Steps>
+  error:
+    | (Steps[number]["provide"] extends Context.Context<infer _P> | Layer.Layer<infer _P, infer E, infer _R> ? E
+      : never)
+    | (Steps[number]["while"] extends (input: infer _I) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never)
+  requirements:
+    | (Steps[number]["provide"] extends Layer.Layer<infer _A, infer _E, infer R> ? R : never)
+    | (Steps[number]["while"] extends (input: infer _I) => Effect.Effect<infer _A, infer _E, infer R> ? R : never)
+    | (Steps[number]["schedule"] extends Schedule.Schedule<infer _O, infer _I, infer R> ? R : never)
+}> =>
+  makeProto(steps.map((options, i) => {
+    if (options.attempts && options.attempts < 1) {
+      throw new Error(`ExecutionPlan.make: step[${i}].attempts must be greater than 0`)
+    }
+    return {
+      schedule: options.schedule,
+      attempts: options.attempts,
+      while: options.while
+        ? (input: any) =>
+          Effect.suspend(() => {
+            const result = options.while!(input)
+            return typeof result === "boolean" ? Effect.succeed(result) : result
+          })
+        : undefined,
+      provide: options.provide
+    }
+  }) as any)
+
+/**
+ * @since 3.16.0
+ * @experimental
+ */
+export declare namespace make {
+  /**
+   * @since 3.16.0
+   * @experimental
+   */
+  export type Step = {
+    readonly provide: Context.Context<any> | Context.Context<never> | Layer.Layer.Any
+    readonly attempts?: number | undefined
+    readonly while?: ((input: any) => boolean | Effect.Effect<boolean, any, any>) | undefined
+    readonly schedule?: Schedule.Schedule<any, any, any> | undefined
+  }
+
+  /**
+   * @since 3.16.1
+   * @experimental
+   */
+  export type StepProvides<Steps extends ReadonlyArray<any>, Out = unknown> = Steps extends
+    readonly [infer Step, ...infer Rest] ? StepProvides<
+      Rest,
+      & Out
+      & (
+        (Step extends { readonly provide: Context.Context<infer P> | Layer.Layer<infer P, infer _E, infer _R> } ? P
+          : unknown)
+      )
+    > :
+    Out
+
+  /**
+   * @since 3.16.1
+   * @experimental
+   */
+  export type PlanProvides<Plans extends ReadonlyArray<any>, Out = unknown> = Plans extends
+    readonly [infer Plan, ...infer Rest] ?
+    PlanProvides<Rest, Out & (Plan extends ExecutionPlan<infer T> ? T["provides"] : unknown)> :
+    Out
+
+  /**
+   * @since 3.16.0
+   * @experimental
+   */
+  export type StepInput<Steps extends ReadonlyArray<any>, Out = unknown> = Steps extends
+    readonly [infer Step, ...infer Rest] ? StepInput<
+      Rest,
+      & Out
+      & (
+        & (Step extends { readonly while: (input: infer I) => infer _ } ? I : unknown)
+        & (Step extends { readonly schedule: Schedule.Schedule<infer _O, infer I, infer _R> } ? I : unknown)
+      )
+    > :
+    Out
+
+  /**
+   * @since 3.16.0
+   * @experimental
+   */
+  export type PlanInput<Plans extends ReadonlyArray<any>, Out = unknown> = Plans extends
+    readonly [infer Plan, ...infer Rest] ?
+    PlanInput<Rest, Out & (Plan extends ExecutionPlan<infer T> ? T["input"] : unknown)> :
+    Out
+}
+
+const Proto: Omit<ExecutionPlan<any>, "steps"> = {
+  [TypeId]: TypeId,
+  get withRequirements() {
+    const self = this as any as ExecutionPlan<any>
+    return Effect.contextWith((context: Context.Context<any>) =>
+      makeProto(self.steps.map((step) => ({
+        ...step,
+        provide: Layer.isLayer(step.provide) ? Layer.provide(step.provide, Layer.succeedContext(context)) : step.provide
+      })) as any)
+    )
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const makeProto = <Provides, In, PlanE, PlanR>(
+  steps: ExecutionPlan<{
+    provides: Provides
+    input: In
+    error: PlanE
+    requirements: PlanR
+  }>["steps"]
+) => {
+  const self = Object.create(Proto)
+  self.steps = steps
+  return self
+}
+
+/**
+ * @since 3.16.0
+ * @category Combining
+ * @experimental
+ */
+export const merge = <const Plans extends NonEmptyReadonlyArray<ExecutionPlan<any>>>(
+  ...plans: Plans
+): ExecutionPlan<{
+  provides: make.PlanProvides<Plans>
+  input: make.PlanInput<Plans>
+  error: Plans[number] extends ExecutionPlan<infer T> ? T["error"] : never
+  requirements: Plans[number] extends ExecutionPlan<infer T> ? T["requirements"] : never
+}> => makeProto(plans.flatMap((plan) => plan.steps) as any)

package/src/HashMap.ts

@@ -268,6 +268,62 @@ export const hasHash: {
   <K1 extends K, K, V>(self: HashMap<K, V>, key: K1, hash: number): boolean
 } = HM.hasHash
 
+/**
+ * Checks if an element matching the given predicate exists in the given `HashMap`.
+ *
+ * @example
+ * ```ts
+ * import { HashMap } from "effect"
+ *
+ * const hm = HashMap.make([1, 'a'])
+ * HashMap.hasBy(hm, (value, key) => value === 'a' && key === 1); // -> true
+ * HashMap.hasBy(hm, (value) => value === 'b'); // -> false
+ *
+ * ```
+ *
+ * @since 3.16.0
+ * @category elements
+ */
+export const hasBy: {
+  /**
+   * Checks if an element matching the given predicate exists in the given `HashMap`.
+   *
+   * @example
+   * ```ts
+   * import { HashMap } from "effect"
+   *
+   * const hm = HashMap.make([1, 'a'])
+   * HashMap.hasBy(hm, (value, key) => value === 'a' && key === 1); // -> true
+   * HashMap.hasBy(hm, (value) => value === 'b'); // -> false
+   *
+   * ```
+   *
+   * @since 3.16.0
+   * @category elements
+   */
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): (self: HashMap<K, V>) => boolean
+  /**
+   * Checks if an element matching the given predicate exists in the given `HashMap`.
+   *
+   * @example
+   * ```ts
+   * import { HashMap } from "effect"
+   *
+   * const hm = HashMap.make([1, 'a'])
+   * HashMap.hasBy(hm, (value, key) => value === 'a' && key === 1); // -> true
+   * HashMap.hasBy(hm, (value) => value === 'b'); // -> false
+   *
+   * ```
+   *
+   * @since 3.16.0
+   * @category elements
+   */
+  <K, V>(
+   self: HashMap<K, V>,
+   predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean
+  ): boolean
+} = HM.hasBy
+
 /**
  * Sets the specified key to the specified value using the internal hashing
  * function.

package/src/Iterable.ts

@@ -1538,3 +1538,69 @@ export const cartesian: {
   2,
   <A, B>(self: Iterable<A>, that: Iterable<B>): Iterable<[A, B]> => cartesianWith(self, that, (a, b) => [a, b])
 )
+
+/**
+ * Counts all the element of the given iterable that pass the given predicate
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Iterable } from "effect"
+ *
+ * const result = Iterable.countBy([1, 2, 3, 4, 5], n => n % 2 === 0)
+ * console.log(result) // 2
+ * ```
+ *
+ * @category folding
+ * @since 3.16.0
+ */
+export const countBy: {
+  /**
+   * Counts all the element of the given iterable that pass the given predicate
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { Iterable } from "effect"
+   *
+   * const result = Iterable.countBy([1, 2, 3, 4, 5], n => n % 2 === 0)
+   * console.log(result) // 2
+   * ```
+   *
+   * @category folding
+   * @since 3.16.0
+   */
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => number
+  /**
+   * Counts all the element of the given iterable that pass the given predicate
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { Iterable } from "effect"
+   *
+   * const result = Iterable.countBy([1, 2, 3, 4, 5], n => n % 2 === 0)
+   * console.log(result) // 2
+   * ```
+   *
+   * @category folding
+   * @since 3.16.0
+   */
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): number
+} = dual(
+  2,
+  <A>(
+    self: Iterable<A>,
+    f: (a: A, i: number) => boolean
+  ): number => {
+    let count = 0
+    let i = 0
+    for (const a of self) {
+      if (f(a, i)) {
+        count++
+      }
+      i++
+    }
+    return count
+  }
+)