<Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>Invalidates all entries in the cache.
Example (Invalidating all entries)
import { Cache, Effect } from "effect"
// Clear all cached entries at once
const program = Effect.gen(function*() {
const cache = yield* Cache.make({
capacity: 10,
lookup: (key: string) => Effect.succeed(key.length)
})
// Populate cache with multiple entries
yield* Cache.get(cache, "apple")
yield* Cache.get(cache, "banana")
yield* Cache.get(cache, "cherry")
console.log(yield* Cache.size(cache)) // 3
console.log(yield* Cache.has(cache, "apple")) // true
// Clear all entries
yield* Cache.invalidateAll(cache)
// Verify cache is empty
console.log(yield* Cache.size(cache)) // 0
console.log(yield* Cache.has(cache, "apple")) // false
console.log(yield* Cache.has(cache, "banana")) // false
console.log(yield* Cache.has(cache, "cherry")) // false
})combinators
Source effect/Cache.ts:11434 lines
export const const invalidateAll: <Key, A, E, R>(
self: Cache<Key, A, E, R>
) => Effect.Effect<void>
Invalidates all entries in the cache.
Example (Invalidating all entries)
import { Cache, Effect } from "effect"
// Clear all cached entries at once
const program = Effect.gen(function*() {
const cache = yield* Cache.make({
capacity: 10,
lookup: (key: string) => Effect.succeed(key.length)
})
// Populate cache with multiple entries
yield* Cache.get(cache, "apple")
yield* Cache.get(cache, "banana")
yield* Cache.get(cache, "cherry")
console.log(yield* Cache.size(cache)) // 3
console.log(yield* Cache.has(cache, "apple")) // true
// Clear all entries
yield* Cache.invalidateAll(cache)
// Verify cache is empty
console.log(yield* Cache.size(cache)) // 0
console.log(yield* Cache.has(cache, "apple")) // false
console.log(yield* Cache.has(cache, "banana")) // false
console.log(yield* Cache.has(cache, "cherry")) // false
})
invalidateAll = <function (type parameter) Key in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>Key, function (type parameter) A in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>A, function (type parameter) E in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>E, function (type parameter) R in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>R>(self: Cache<Key, A, E, R>(parameter) self: {
map: MutableHashMap.MutableHashMap<Key, Entry<A, E>>;
capacity: number;
lookup: (key: Key) => Effect.Effect<A, E, R>;
timeToLive: (exit: Exit.Exit<A, E>, key: Key) => Duration.Duration;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Cache<in out Key, in out A, in out E = never, out R = never>A cache interface that provides a mutable key-value store with automatic TTL management,
capacity limits, and lookup functions for cache misses.
Example (Creating a basic cache)
import { Cache, Effect } from "effect"
// Basic cache with string keys and number values
const program = Effect.gen(function*() {
const cache = yield* Cache.make<string, number>({
capacity: 100,
lookup: (key: string) => Effect.succeed(key.length)
})
// Cache operations
const value1 = yield* Cache.get(cache, "hello") // 5
const value2 = yield* Cache.get(cache, "world") // 5
const value3 = yield* Cache.get(cache, "hello") // 5 (cached)
return [value1, value2, value3]
})
Example (Handling lookup failures)
import { Cache, Effect } from "effect"
// Cache with error handling
const program = Effect.gen(function*() {
const cache = yield* Cache.make<string, number, string>({
capacity: 10,
lookup: (key: string) =>
key === "error"
? Effect.fail("Lookup failed")
: Effect.succeed(key.length)
})
// Handle successful and failed lookups
const success = yield* Cache.get(cache, "test") // 4
const failure = yield* Effect.exit(Cache.get(cache, "error")) // Exit.fail
return { success, failure }
})
Example (Using complex keys with TTL)
import { Cache, Data, Duration, Effect } from "effect"
// Cache with complex key types and TTL
class UserId extends Data.Class<{ id: number }> {}
const program = Effect.gen(function*() {
const userCache = yield* Cache.make<UserId, string>({
capacity: 1000,
lookup: (userId: UserId) => Effect.succeed(`User-${userId.id}`),
timeToLive: Duration.minutes(5)
})
const userId = new UserId({ id: 123 })
const userName = yield* Cache.get(userCache, userId)
return userName // "User-123"
})
Cache<function (type parameter) Key in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>Key, function (type parameter) A in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>A, function (type parameter) E in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>E, function (type parameter) R in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<void>R>): import EffectEffect.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<void> =>
import effecteffect.const sync: <A>(
thunk: LazyArg<A>
) => Effect.Effect<A>
import MutableHashMapMutableHashMap.const clear: <K, V>(
self: MutableHashMap<K, V>
) => MutableHashMap<K, V>
Removes all key-value pairs from the MutableHashMap, mutating the map in place.
The map becomes empty after this operation.
When to use
Use to empty a mutable hash map while keeping the same map instance.
Example (Clearing all entries)
import { MutableHashMap } from "effect"
const map = MutableHashMap.make(
["key1", 42],
["key2", 100],
["key3", 200]
)
console.log(MutableHashMap.size(map)) // 3
// Clear all entries
MutableHashMap.clear(map)
console.log(MutableHashMap.size(map)) // 0
console.log(MutableHashMap.has(map, "key1")) // false
// Can still add new entries after clearing
MutableHashMap.set(map, "new", 999)
console.log(MutableHashMap.size(map)) // 1
clear(self: Cache<Key, A, E, R>(parameter) self: {
map: MutableHashMap.MutableHashMap<Key, Entry<A, E>>;
capacity: number;
lookup: (key: Key) => Effect.Effect<A, E, R>;
timeToLive: (exit: Exit.Exit<A, E>, key: Key) => Duration.Duration;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Cache<Key, A, E, R>.map: MutableHashMap.MutableHashMap<Key, Entry<A, E>>(property) Cache<Key, A, E, R>.map: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}