Caching Effects

This section covers several functions from the library that help manage caching and memoization in your application.

cachedFunction

Memoizes a function with effects, caching results for the same inputs to avoid recomputation.

Example (Memoizing a Random Number Generator)

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

3
const program = Effect.gen(function* () {
4
  const randomNumber = (n: number) => Random.nextIntBetween(1, n)
5
  console.log("non-memoized version:")
6
  console.log(yield* randomNumber(10)) // Generates a new random number
7
  console.log(yield* randomNumber(10)) // Generates a different number
8

9
  console.log("memoized version:")
10
  const memoized = yield* Effect.cachedFunction(randomNumber)
11
  console.log(yield* memoized(10)) // Generates and caches the result
12
  console.log(yield* memoized(10)) // Reuses the cached result
13
})
14

15
Effect.runFork(program)
16
/*
17
Example Output:
18
non-memoized version:
19
2
20
8
21
memoized version:
22
5
23
5
24
*/

once

Ensures an effect is executed only once, even if invoked multiple times.

Example (Single Execution of an Effect)

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

3
const program = Effect.gen(function* () {
4
  const task1 = Console.log("task1")
5

6
  // Repeats task1 three times
7
  yield* Effect.repeatN(task1, 2)
8

9
  // Ensures task2 is executed only once
10
  const task2 = yield* Effect.once(Console.log("task2"))
11

12
  // Attempts to repeat task2, but it will only execute once
13
  yield* Effect.repeatN(task2, 2)
14
})
15

16
Effect.runFork(program)
17
/*
18
Output:
19
task1
20
task1
21
task1
22
task2
23
*/

cached

Returns an effect that computes a result lazily and caches it. Subsequent evaluations of this effect will return the cached result without re-executing the logic.

Example (Lazy Caching of an Expensive Task)

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

3
let i = 1
4

5
// Simulating an expensive task with a delay
6
const expensiveTask = Effect.promise<string>(() => {
7
  console.log("expensive task...")
8
  return new Promise((resolve) => {
9
    setTimeout(() => {
10
      resolve(`result ${i++}`)
11
    }, 100)
12
  })
13
})
14

15
const program = Effect.gen(function* () {
16
  // Without caching, the task is executed each time
17
  console.log("-- non-cached version:")
18
  yield* expensiveTask.pipe(Effect.andThen(Console.log))
19
  yield* expensiveTask.pipe(Effect.andThen(Console.log))
20

21
  // With caching, the result is reused after the first run
22
  console.log("-- cached version:")
23
  const cached = yield* Effect.cached(expensiveTask)
24
  yield* cached.pipe(Effect.andThen(Console.log))
25
  yield* cached.pipe(Effect.andThen(Console.log))
26
})
27

28
Effect.runFork(program)
29
/*
30
Output:
31
-- non-cached version:
32
expensive task...
33
result 1
34
expensive task...
35
result 2
36
-- cached version:
37
expensive task...
38
result 3
39
result 3
40
*/

cachedWithTTL

Returns an effect that caches its result for a specified duration, known as the timeToLive. When the cache expires after the duration, the effect will be recomputed upon next evaluation.

Example (Caching with Time-to-Live)

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

3
let i = 1
4

5
// Simulating an expensive task with a delay
6
const expensiveTask = Effect.promise<string>(() => {
7
  console.log("expensive task...")
8
  return new Promise((resolve) => {
9
    setTimeout(() => {
10
      resolve(`result ${i++}`)
11
    }, 100)
12
  })
13
})
14

15
const program = Effect.gen(function* () {
16
  // Caches the result for 150 milliseconds
17
  const cached = yield* Effect.cachedWithTTL(expensiveTask, "150 millis")
18

19
  // First evaluation triggers the task
20
  yield* cached.pipe(Effect.andThen(Console.log))
21

22
  // Second evaluation returns the cached result
23
  yield* cached.pipe(Effect.andThen(Console.log))
24

25
  // Wait for 100 milliseconds, ensuring the cache expires
26
  yield* Effect.sleep("100 millis")
27

28
  // Recomputes the task after cache expiration
29
  yield* cached.pipe(Effect.andThen(Console.log))
30
})
31

32
Effect.runFork(program)
33
/*
34
Output:
35
expensive task...
36
result 1
37
result 1
38
expensive task...
39
result 2
40
*/

cachedInvalidateWithTTL

Similar to Effect.cachedWithTTL, this function caches an effect’s result for a specified duration. It also includes an additional effect for manually invalidating the cached value before it naturally expires.

Example (Invalidating Cache Manually)

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

3
let i = 1
4

5
// Simulating an expensive task with a delay
6
const expensiveTask = Effect.promise<string>(() => {
7
  console.log("expensive task...")
8
  return new Promise((resolve) => {
9
    setTimeout(() => {
10
      resolve(`result ${i++}`)
11
    }, 100)
12
  })
13
})
14

15
const program = Effect.gen(function* () {
16
  // Caches the result for 150 milliseconds
17
  const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL(expensiveTask, "150 millis")
18

19
  // First evaluation triggers the task
20
  yield* cached.pipe(Effect.andThen(Console.log))
21

22
  // Second evaluation returns the cached result
23
  yield* cached.pipe(Effect.andThen(Console.log))
24

25
  // Invalidate the cache before it naturally expires
26
  yield* invalidate
27

28
  // Third evaluation triggers the task again
29
  // since the cache was invalidated
30
  yield* cached.pipe(Effect.andThen(Console.log))
31
})
32

33
Effect.runFork(program)
34
/*
35
Output:
36
expensive task...
37
result 1
38
result 1
39
expensive task...
40
result 2
41
*/