Effect 3.16 (Release)

1
import { type AiLanguageModel } from "@effect/ai"
2
import type { Layer } from "effect"
3
import { Effect, ExecutionPlan, Schedule } from "effect"
4

5
declare const layerBad: Layer.Layer<AiLanguageModel.AiLanguageModel>
6
declare const layerGood: Layer.Layer<AiLanguageModel.AiLanguageModel>
7

8
const AiPlan = ExecutionPlan.make(
9
  {
10
    // First try with the bad layer 2 times with a 3 second delay between attempts
11
    provide: layerBad,
12
    attempts: 2,
13
    schedule: Schedule.spaced(3000),
14
  },
15
  // Then try with the bad layer 3 times with a 1 second delay between attempts
16
  {
17
    provide: layerBad,
18
    attempts: 3,
19
    schedule: Schedule.spaced(1000),
20
  },
21
  // Finally try with the good layer.
22
  //
23
  // If `attempts` is omitted, the plan will only attempt once, unless a schedule is provided.
24
  {
25
    provide: layerGood,
26
  },
27
)
28

29
declare const effect: Effect.Effect<void, never, AiLanguageModel.AiLanguageModel>
30
const withPlan: Effect.Effect<void> = Effect.withExecutionPlan(effect, AiPlan)

1
import type { Layer } from "effect"
2
import { Effect } from "effect"
3

4
class NumberService extends Effect.Service<NumberService>()("NumberService", {
5
  // You can now pass a function to the `effect` and `scoped` constructors
6
  effect: Effect.fn(function* (input: number) {
7
    return {
8
      get: Effect.succeed(`The number is: ${input}`),
9
    } as const
10
  }),
11
}) {}
12

13
// Pass the arguments to the `Default` layer
14
const CoolNumberServiceLayer: Layer.Layer<NumberService> = NumberService.Default(6942)

1
import { NodeRuntime } from "@effect/platform-node"
2
import { Context, Effect, FiberRef, Layer, LayerMap } from "effect"
3

4
class Greeter extends Context.Tag("Greeter")<
5
  Greeter,
6
  {
7
    greet: Effect.Effect<string>
8
  }
9
>() {}
10

11
// create a service that wraps a LayerMap
12
class GreeterMap extends LayerMap.Service<GreeterMap>()("GreeterMap", {
13
  // define the lookup function for the layer map
14
  //
15
  // The returned Layer will be used to provide the Greeter service for the
16
  // given name.
17
  lookup: (name: string) =>
18
    Layer.succeed(Greeter, {
19
      greet: Effect.succeed(`Hello, ${name}!`),
20
    }),
21

22
  // If a layer is not used for a certain amount of time, it can be removed
23
  idleTimeToLive: "5 seconds",
24

25
  // Supply the dependencies for the layers in the LayerMap
26
  dependencies: [],
27
}) {}
28

29
// usage
30
const program: Effect.Effect<void, never, GreeterMap> = Effect.gen(function* () {
31
  // access and use the Greeter service
32
  const greeter = yield* Greeter
33
  yield* Effect.log(yield* greeter.greet)
34
}).pipe(
35
  // use the GreeterMap service to provide a variant of the Greeter service
36
  Effect.provide(GreeterMap.get("John")),
37
)
38

39
// run the program
40
program.pipe(Effect.provide(GreeterMap.Default), NodeRuntime.runMain)

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

3
Effect.gen(function* () {
4
  // You can now access the following information when inside a Schedule execution.
5
  //
6
  // {
7
  //   elapsed: Duration.zero,
8
  //   elapsedSincePrevious: Duration.zero,
9
  //   input: undefined,
10
  //   now: 0,
11
  //   recurrence: 2,
12
  //   start: 0
13
  // }
14
  const currentIterationMetadata = yield* Schedule.CurrentIterationMetadata
15
}).pipe(Effect.repeat(Schedule.recurs(2)))

1
import { Brand, Config } from "effect"
2

3
// ensures that the value is a valid port number
4
const dbPort: Config.Config<number> = Config.port("DB_PORT")

1
import { Brand, Config } from "effect"
2

3
type Port = Brand.Branded<number, "Port">
4
const Port = Brand.refined<Port>(
5
  (num) => !Number.isNaN(num) && Number.isInteger(num) && num >= 1 && num <= 65535,
6
  (n) => Brand.error(`Expected ${n} to be an TCP port`),
7
)
8

9
const dbPort: Config.Config<Port> = Config.number("DB_PORT").pipe(
10
  // refine the config value using a brand constructor
11
  Config.branded(Port),
12
)