<Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<number>Retrieves the approximate number of entries in the cache.
Details
Note that expired entries are counted until they are accessed and removed. The size reflects the current number of entries stored, not the number of valid entries.
Example (Reading cache size)
import { Cache, Effect } from "effect"
const program = Effect.gen(function*() {
const cache = yield* Cache.make({
capacity: 10,
lookup: (key: string) => Effect.succeed(key.length)
})
// Empty cache has size 0
const emptySize = yield* Cache.size(cache)
console.log(emptySize) // 0
// Add entries and check size
yield* Cache.get(cache, "hello")
yield* Cache.get(cache, "world")
const sizeAfterAdding = yield* Cache.size(cache)
console.log(sizeAfterAdding) // 2
// Size decreases after invalidation
yield* Cache.invalidate(cache, "hello")
const sizeAfterInvalidation = yield* Cache.size(cache)
console.log(sizeAfterInvalidation) // 1
})export const const size: <Key, A, E, R>(
self: Cache<Key, A, E, R>
) => Effect.Effect<number>
Retrieves the approximate number of entries in the cache.
Details
Note that expired entries are counted until they are accessed and removed.
The size reflects the current number of entries stored, not the number
of valid entries.
Example (Reading cache size)
import { Cache, Effect } from "effect"
const program = Effect.gen(function*() {
const cache = yield* Cache.make({
capacity: 10,
lookup: (key: string) => Effect.succeed(key.length)
})
// Empty cache has size 0
const emptySize = yield* Cache.size(cache)
console.log(emptySize) // 0
// Add entries and check size
yield* Cache.get(cache, "hello")
yield* Cache.get(cache, "world")
const sizeAfterAdding = yield* Cache.size(cache)
console.log(sizeAfterAdding) // 2
// Size decreases after invalidation
yield* Cache.invalidate(cache, "hello")
const sizeAfterInvalidation = yield* Cache.size(cache)
console.log(sizeAfterInvalidation) // 1
})
size = <function (type parameter) Key in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<number>Key, function (type parameter) A in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<number>A, function (type parameter) E in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<number>E, function (type parameter) R in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<number>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<number>Key, function (type parameter) A in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<number>A, function (type parameter) E in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<number>E, function (type parameter) R in <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<number>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<number> =>
import effecteffect.const sync: <A>(
thunk: LazyArg<A>
) => Effect.Effect<A>
import MutableHashMapMutableHashMap.const size: <K, V>(
self: MutableHashMap<K, V>
) => number
Returns the number of key-value pairs in the MutableHashMap.
When to use
Use to read how many entries are currently stored in the mutable hash map.
Example (Checking map size)
import { MutableHashMap } from "effect"
const map = MutableHashMap.empty<string, number>()
console.log(MutableHashMap.size(map)) // 0
MutableHashMap.set(map, "key1", 42)
MutableHashMap.set(map, "key2", 100)
console.log(MutableHashMap.size(map)) // 2
MutableHashMap.remove(map, "key1")
console.log(MutableHashMap.size(map)) // 1
MutableHashMap.clear(map)
console.log(MutableHashMap.size(map)) // 0
size(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;
}