Effect 3.17 (Release)

Effect 3.17 has been released! This release includes a number of new features and improvements. Here’s a summary of what’s new:

Layer.mock

Layer.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.

1
import { Context, Effect, Layer } from "effect"
2

3
class MyService extends Context.Tag("MyService")<
4
  MyService,
5
  {
6
    one: Effect.Effect<number>
7
    two(): Effect.Effect<number>
8
  }
9
>() {}
10

11
// Mocking a service with a partial implementation
12
const MyServiceTest = Layer.mock(MyService, {
13
  two: () => Effect.succeed(2),
14
})

Random.fixed

Create a version of 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.

1
import { Effect, Random } from "effect"
2

3
Effect.gen(function* () {
4
  console.log(yield* Random.next) // 0.2
5
  console.log(yield* Random.next) // 0.5
6
  console.log(yield* Random.next) // 0.8
7
  console.log(yield* Random.next) // 0.2 (cycles back)
8
}).pipe(Effect.withRandom(Random.fixed([0.2, 0.5, 0.8])))

Effect.ensure{Success,Error,Requirements}

These new functions allow you to ensure that the Success, Error, or Requirements of an effect are assignable to a specific type.

This is useful for ensuring that your effects have a certain return type, or that they handle errors correctly.

1
import { Effect } from "effect"
2

3
// Ensure that the program does not expose any unhandled errors.
4
const program = Effect.succeed(42).pipe(Effect.ensureErrorType<never>())

Struct.entries

Struct.entries is a version of Object.entries that enhances the type safety of the entries returned from an object.

1
import { Struct } from "effect"
2

3
const c = Symbol("c")
4
const value = { a: "foo", b: 1, [c]: true }
5

6
// The type of `entries` is now more specific
7
const entries: Array<["a" | "b", string | number]> = Struct.entries(value)

Other changes

• HashMap.countBy has been added, allowing you to count occurrences of elements in a collection.
• Array.findFirstWithIndex has been added, enabling you to find the first element that matches a predicate along with its index.
• Schedule CurrentIterationMetadata now includes the schedule output.
• Effect runtime version mismatches are now warnings instead of errors.

There were several other smaller changes made. Take a look through the CHANGELOG to see them all: CHANGELOG.

Don’t forget to join our Discord Community to follow the last updates and discuss every tiny detail!