effect 3.16.17 → 3.17.0

package/src/HashMap.ts

@@ -403,6 +403,62 @@ export const toEntries = <K, V>(self: HashMap<K, V>): Array<[K, V]> => Array.fro
  */
 export const size: <K, V>(self: HashMap<K, V>) => number = HM.size
 
+/**
+ * Counts all the element of the given HashMap that pass the given predicate
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { HashMap } from "effect"
+ *
+ * const map = HashMap.make([1, "a"], [2, "b"], [3, "c"])
+ * const result = HashMap.countBy(map, (_v, key) => key % 2 === 1)
+ * console.log(result) // 2
+ * ```
+ *
+ * @since 3.17.0
+ * @category folding
+ */
+export const countBy: {
+  /**
+   * Counts all the element of the given HashMap that pass the given predicate
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { HashMap } from "effect"
+   *
+   * const map = HashMap.make([1, "a"], [2, "b"], [3, "c"])
+   * const result = HashMap.countBy(map, (_v, key) => key % 2 === 1)
+   * console.log(result) // 2
+   * ```
+   *
+   * @since 3.17.0
+   * @category folding
+   */
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): (self: HashMap<K, V>) => number
+  /**
+   * Counts all the element of the given HashMap that pass the given predicate
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { HashMap } from "effect"
+   *
+   * const map = HashMap.make([1, "a"], [2, "b"], [3, "c"])
+   * const result = HashMap.countBy(map, (_v, key) => key % 2 === 1)
+   * console.log(result) // 2
+   * ```
+   *
+   * @since 3.17.0
+   * @category folding
+   */
+  <K, V>(
+   self: HashMap<K, V>,
+   predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean
+  ): number
+} = HM.countBy
+
 /**
  * Marks the `HashMap` as mutable.
  *

package/src/Layer.ts

@@ -498,6 +498,109 @@ export const flatten: {
  */
 export const fresh: <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R> = internal.fresh
 
+/**
+ * @since 3.17.0
+ * @category Testing
+ */
+export type PartialEffectful<A extends object> = Types.Simplify<
+  & {
+    [
+      K in keyof A as A[K] extends Effect.Effect<any, any, any> | ((...args: any) => Effect.Effect<any, any, any>) ? K
+        : never
+    ]?: A[K]
+  }
+  & {
+    [
+      K in keyof A as A[K] extends Effect.Effect<any, any, any> | ((...args: any) => Effect.Effect<any, any, any>) ?
+        never
+        : K
+    ]: A[K]
+  }
+>
+
+/**
+ * Creates a mock layer for testing purposes. You can provide a partial
+ * implementation of the service, and any methods not provided will
+ * throw an `UnimplementedError` defect when called.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Context, Effect, Layer } from "effect"
+ *
+ * class MyService extends Context.Tag("MyService")<
+ *   MyService,
+ *   {
+ *     one: Effect.Effect<number>
+ *     two(): Effect.Effect<number>
+ *   }
+ * >() {}
+ *
+ * const MyServiceTest = Layer.mock(MyService, {
+ *   two: () => Effect.succeed(2)
+ * })
+ * ```
+ *
+ * @since 3.17.0
+ * @category Testing
+ */
+export const mock: {
+  /**
+   * Creates a mock layer for testing purposes. You can provide a partial
+   * implementation of the service, and any methods not provided will
+   * throw an `UnimplementedError` defect when called.
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { Context, Effect, Layer } from "effect"
+   *
+   * class MyService extends Context.Tag("MyService")<
+   *   MyService,
+   *   {
+   *     one: Effect.Effect<number>
+   *     two(): Effect.Effect<number>
+   *   }
+   * >() {}
+   *
+   * const MyServiceTest = Layer.mock(MyService, {
+   *   two: () => Effect.succeed(2)
+   * })
+   * ```
+   *
+   * @since 3.17.0
+   * @category Testing
+   */
+  <I, S extends object>(tag: Context.Tag<I, S>): (service: PartialEffectful<S>) => Layer<I>
+  /**
+   * Creates a mock layer for testing purposes. You can provide a partial
+   * implementation of the service, and any methods not provided will
+   * throw an `UnimplementedError` defect when called.
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { Context, Effect, Layer } from "effect"
+   *
+   * class MyService extends Context.Tag("MyService")<
+   *   MyService,
+   *   {
+   *     one: Effect.Effect<number>
+   *     two(): Effect.Effect<number>
+   *   }
+   * >() {}
+   *
+   * const MyServiceTest = Layer.mock(MyService, {
+   *   two: () => Effect.succeed(2)
+   * })
+   * ```
+   *
+   * @since 3.17.0
+   * @category Testing
+   */
+  <I, S extends object>(tag: Context.Tag<I, S>, service: PartialEffectful<S>): Layer<I>
+} = internal.mock
+
 const fromFunction: <I1, S1, I2, S2>(
   tagA: Context.Tag<I1, S1>,
   tagB: Context.Tag<I2, S2>,
@@ -1400,6 +1503,17 @@ export const setUnhandledErrorLogLevel: (level: Option.Option<LogLevel>) => Laye
     fiberRuntime.fiberRefLocallyScoped(core.currentUnhandledErrorLogLevel, level)
   )
 
+/**
+ * @since 3.17.0
+ * @category logging
+ */
+export const setVersionMismatchErrorLogLevel: (level: Option.Option<LogLevel>) => Layer<never> = (
+  level: Option.Option<LogLevel>
+): Layer<never> =>
+  scopedDiscard(
+    fiberRuntime.fiberRefLocallyScoped(core.currentVersionMismatchErrorLogLevel, level)
+  )
+
 /**
  * @since 2.0.0
  * @category tracing

package/src/Random.ts

@@ -169,3 +169,36 @@ export const Random: Context.Tag<Random, Random> = internal.randomTag
  * @category constructors
  */
 export const make: <A>(seed: A) => Random = internal.make
+
+/**
+ * Constructs the `Random` service from an array of literal values.
+ * The service will cycle through the provided values in order when generating random values.
+ * This constructor is useful for creating deterministic sequences for testing or when specific values need to be returned.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * Effect.gen(function* () {
+ *   console.log(yield* Random.next) // 0.2
+ *   console.log(yield* Random.next) // 0.5
+ *   console.log(yield* Random.next) // 0.8
+ *   console.log(yield* Random.next) // 0.2 (cycles back)
+ * }).pipe(Effect.withRandom(Random.fixed([0.2, 0.5, 0.8])))
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * Effect.gen(function* () {
+ *   console.log(yield* Random.nextBoolean) // true
+ *   console.log(yield* Random.nextBoolean) // false
+ *   console.log(yield* Random.nextBoolean) // true
+ * }).pipe(Effect.withRandom(Random.fixed([true, false, true])))
+ * ```
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export const fixed: <const T extends Array.NonEmptyArray<any>>(values: T) => Random = internal.fixed

package/src/Schedule.ts

@@ -3722,6 +3722,7 @@ export interface CurrentIterationMetadata {
  */
 export interface IterationMetadata {
   readonly input: unknown
+  readonly output: unknown
   readonly recurrence: number
   readonly start: number
   readonly now: number

package/src/Struct.ts

@@ -311,3 +311,25 @@ export const get =
  * @since 3.6.0
  */
 export const keys = <T extends {}>(o: T): Array<(keyof T) & string> => Object.keys(o) as Array<(keyof T) & string>
+
+/**
+ * Retrieves the entries (key-value pairs) of an object, where keys are strings,
+ * in a type-safe manner. Symbol keys are excluded from the result.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Struct } from "effect"
+ *
+ * const c = Symbol("c")
+ * const value = { a: "foo", b: 1, [c]: true }
+ *
+ * const entries: Array<["a" | "b", string | number]> = Struct.entries(value)
+ *
+ * assert.deepStrictEqual(entries, [["a", "foo"], ["b", 1]])
+ * ```
+ *
+ * @since 3.17.0
+ */
+export const entries = <const R>(obj: R): Array<[keyof R & string, R[keyof R & string]]> =>
+  Object.entries(obj as any) as any

package/src/internal/core.ts

@@ -2082,6 +2082,12 @@ export const currentUnhandledErrorLogLevel: FiberRef.FiberRef<Option.Option<LogL
   () => fiberRefUnsafeMake(Option.some<LogLevel.LogLevel>(logLevelDebug))
 )
 
+/** @internal */
+export const currentVersionMismatchErrorLogLevel: FiberRef.FiberRef<Option.Option<LogLevel.LogLevel>> = globalValue(
+  Symbol.for("effect/FiberRef/versionMismatchErrorLogLevel"),
+  () => fiberRefUnsafeMake(Option.some<LogLevel.LogLevel>(logLevelWarning))
+)
+
 /** @internal */
 export const withUnhandledErrorLogLevel = dual<
   (level: Option.Option<LogLevel.LogLevel>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,

package/src/internal/fiberRuntime.ts

@@ -1370,11 +1370,15 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
         cur = this.currentTracer.context(
           () => {
             if (_version !== (cur as core.Primitive)[core.EffectTypeId]._V) {
-              return core.dieMessage(
-                `Cannot execute an Effect versioned ${
-                  (cur as core.Primitive)[core.EffectTypeId]._V
-                } with a Runtime of version ${version.getCurrentVersion()}`
-              )
+              const level = this.getFiberRef(core.currentVersionMismatchErrorLogLevel)
+              if (level._tag === "Some") {
+                const effectVersion = (cur as core.Primitive)[core.EffectTypeId]._V
+                this.log(
+                  `Executing an Effect versioned ${effectVersion} with a Runtime of version ${version.getCurrentVersion()}, you may want to dedupe the effect dependencies, you can use the language service plugin to detect this at compile time: https://github.com/Effect-TS/language-service`,
+                  internalCause.empty,
+                  level
+                )
+              }
             }
             // @ts-expect-error
             return this[(cur as core.Primitive)._op](cur as core.Primitive)

package/src/internal/hashMap.ts

@@ -334,6 +334,20 @@ export const entries = <K, V>(self: HM.HashMap<K, V>): IterableIterator<[K, V]>
 /** @internal */
 export const size = <K, V>(self: HM.HashMap<K, V>): number => (self as HashMapImpl<K, V>)._size
 
+/** @internal */
+export const countBy = Dual.dual<
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean) => (self: HM.HashMap<K, V>) => number,
+  <K, V>(self: HM.HashMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean) => number
+>(2, (self, f) => {
+  let count = 0
+  for (const [k, a] of self) {
+    if (f(a, k)) {
+      count++
+    }
+  }
+  return count
+})
+
 /** @internal */
 export const beginMutation = <K, V>(self: HM.HashMap<K, V>): HM.HashMap<K, V> =>
   makeImpl(

package/src/internal/layer.ts

@@ -7,7 +7,7 @@ import type * as Exit from "../Exit.js"
 import type { FiberRef } from "../FiberRef.js"
 import * as FiberRefsPatch from "../FiberRefsPatch.js"
 import type { LazyArg } from "../Function.js"
-import { dual, pipe } from "../Function.js"
+import { constTrue, dual, pipe } from "../Function.js"
 import * as HashMap from "../HashMap.js"
 import type * as Layer from "../Layer.js"
 import type * as ManagedRuntime from "../ManagedRuntime.js"
@@ -638,6 +638,43 @@ export const launch = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): Effect.Ef
     )
   )
 
+/** @internal */
+export const mock: {
+  <I, S extends object>(tag: Context.Tag<I, S>): (service: Layer.PartialEffectful<S>) => Layer.Layer<I>
+  <I, S extends object>(tag: Context.Tag<I, S>, service: Layer.PartialEffectful<S>): Layer.Layer<I>
+} = dual(
+  2,
+  <I, S extends object>(tag: Context.Tag<I, S>, service: Layer.PartialEffectful<S>): Layer.Layer<I> =>
+    succeed(
+      tag,
+      new Proxy({ ...service as object } as S, {
+        get(target, prop, _receiver) {
+          if (prop in target) {
+            return target[prop as keyof S]
+          }
+          const prevLimit = Error.stackTraceLimit
+          Error.stackTraceLimit = 2
+          const error = new Error(`${tag.key}: Unimplemented method "${prop.toString()}"`)
+          Error.stackTraceLimit = prevLimit
+          error.name = "UnimplementedError"
+          return makeUnimplemented(error)
+        },
+        has: constTrue
+      })
+    )
+)
+
+const makeUnimplemented = (error: Error) => {
+  const dead = core.die(error)
+  function unimplemented() {
+    return dead
+  }
+  // @effect-diagnostics-next-line floatingEffect:off
+  Object.assign(unimplemented, dead)
+  Object.setPrototypeOf(unimplemented, Object.getPrototypeOf(dead))
+  return unimplemented
+}
+
 /** @internal */
 export const map = dual<
   <A, B>(

package/src/internal/random.ts

@@ -1,3 +1,4 @@
+import type * as Arr from "../Array.js"
 import * as Chunk from "../Chunk.js"
 import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
@@ -87,3 +88,74 @@ const swap = <A>(buffer: Array<A>, index1: number, index2: number): Array<A> =>
 }
 
 export const make = <A>(seed: A): Random.Random => new RandomImpl(Hash.hash(seed))
+
+/** @internal */
+class FixedRandomImpl implements Random.Random {
+  readonly [RandomTypeId]: Random.RandomTypeId = RandomTypeId
+
+  private index = 0
+
+  constructor(readonly values: Arr.NonEmptyArray<any>) {
+    if (values.length === 0) {
+      throw new Error("Requires at least one value")
+    }
+  }
+
+  private getNextValue(): any {
+    const value = this.values[this.index]
+    this.index = (this.index + 1) % this.values.length
+    return value
+  }
+
+  get next(): Effect.Effect<number> {
+    return core.sync(() => {
+      const value = this.getNextValue()
+      if (typeof value === "number") {
+        return Math.max(0, Math.min(1, value))
+      }
+      return Hash.hash(value) / 2147483647
+    })
+  }
+
+  get nextBoolean(): Effect.Effect<boolean> {
+    return core.sync(() => {
+      const value = this.getNextValue()
+      if (typeof value === "boolean") {
+        return value
+      }
+      return Hash.hash(value) % 2 === 0
+    })
+  }
+
+  get nextInt(): Effect.Effect<number> {
+    return core.sync(() => {
+      const value = this.getNextValue()
+      if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.round(value)
+      }
+      return Math.abs(Hash.hash(value))
+    })
+  }
+
+  nextRange(min: number, max: number): Effect.Effect<number> {
+    return core.map(this.next, (n) => (max - min) * n + min)
+  }
+
+  nextIntBetween(min: number, max: number): Effect.Effect<number> {
+    return core.sync(() => {
+      const value = this.getNextValue()
+      if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.max(min, Math.min(max - 1, Math.round(value)))
+      }
+      const hash = Math.abs(Hash.hash(value))
+      return min + (hash % (max - min))
+    })
+  }
+
+  shuffle<A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>> {
+    return shuffleWith(elements, (n) => this.nextIntBetween(0, n))
+  }
+}
+
+/** @internal */
+export const fixed = <T extends Arr.NonEmptyArray<any>>(values: T): Random.Random => new FixedRandomImpl(values)

package/src/internal/schedule.ts

@@ -53,6 +53,7 @@ const defaultIterationMetadata: Schedule.IterationMetadata = {
   start: 0,
   now: 0,
   input: undefined,
+  output: undefined,
   elapsed: Duration.zero,
   elapsedSincePrevious: Duration.zero,
   recurrence: 0
@@ -103,13 +104,15 @@ class ScheduleImpl<S, Out, In, R> implements Schedule.Schedule<Out, In, R> {
 const updateInfo = (
   iterationMetaRef: Ref.Ref<Schedule.IterationMetadata>,
   now: number,
-  input: unknown
+  input: unknown,
+  output: unknown
 ) =>
   ref.update(iterationMetaRef, (prev) =>
     (prev.recurrence === 0) ?
       {
         now,
         input,
+        output,
         recurrence: prev.recurrence + 1,
         elapsed: Duration.zero,
         elapsedSincePrevious: Duration.zero,
@@ -118,6 +121,7 @@ const updateInfo = (
       {
         now,
         input,
+        output,
         recurrence: prev.recurrence + 1,
         elapsed: Duration.millis(now - prev.start),
         elapsedSincePrevious: Duration.millis(now - prev.now),
@@ -177,14 +181,14 @@ class ScheduleDriverImpl<Out, In, R> implements Schedule.ScheduleDriver<Out, In,
                 const millis = Intervals.start(decision.intervals) - now
                 if (millis <= 0) {
                   return setState.pipe(
-                    core.zipRight(updateInfo(this.iterationMeta, now, input)),
+                    core.zipRight(updateInfo(this.iterationMeta, now, input, out)),
                     core.as(out)
                   )
                 }
                 const duration = Duration.millis(millis)
                 return pipe(
                   setState,
-                  core.zipRight(updateInfo(this.iterationMeta, now, input)),
+                  core.zipRight(updateInfo(this.iterationMeta, now, input, out)),
                   core.zipRight(effect.sleep(duration)),
                   core.as(out)
                 )

package/src/internal/version.ts

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