Pool
Combinators
invalidate
Invalidates the specified item. This will cause the pool to eventually reallocate the item, although this reallocation may occur lazily rather than eagerly.
Signature
declare const invalidate: { <A>(value: A): <E>(self: Pool<A, E>) => Effect<void, never, Scope>; <A, E>(self: Pool<A, E>, value: A): Effect<void, never, Scope>;}Constructors
Makes a new pool of the specified fixed size. The pool is returned in a
Scope, which governs the lifetime of the pool. When the pool is shutdown
because the Scope is closed, the individual items allocated by the pool
will be released in some unspecified order.
By setting the concurrency parameter, you can control the level of concurrent
access per pool item. By default, the number of permits is set to 1.
targetUtilization determines when to create new pool items. It is a value
between 0 and 1, where 1 means only create new pool items when all the existing
items are fully utilized.
A targetUtilization of 0.5 will create new pool items when the existing items are
50% utilized.
Signature
declare const make: <A, E, R>(options: { readonly acquire: Effect.Effect<A, E, R>; readonly concurrency?: number; readonly size: number; readonly targetUtilization?: number;}) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R>makeWithTTL
Makes a new pool with the specified minimum and maximum sizes and time to
live before a pool whose excess items are not being used will be shrunk
down to the minimum size. The pool is returned in a Scope, which governs
the lifetime of the pool. When the pool is shutdown because the Scope is
used, the individual items allocated by the pool will be released in some
unspecified order.
By setting the concurrency parameter, you can control the level of concurrent
access per pool item. By default, the number of permits is set to 1.
targetUtilization determines when to create new pool items. It is a value
between 0 and 1, where 1 means only create new pool items when all the existing
items are fully utilized.
A targetUtilization of 0.5 will create new pool items when the existing items are
50% utilized.
The timeToLiveStrategy determines how items are invalidated. If set to
"creation", then items are invalidated based on their creation time. If set
to "usage", then items are invalidated based on pool usage.
By default, the timeToLiveStrategy is set to "usage".
Signature
declare const makeWithTTL: <A, E, R>(options: { readonly acquire: Effect.Effect<A, E, R>; readonly concurrency?: number; readonly max: number; readonly min: number; readonly targetUtilization?: number; readonly timeToLive: Duration.DurationInput; readonly timeToLiveStrategy?: "creation" | "usage";}) => Effect.Effect<Pool<A, E>, never, Scope.Scope | R>Example
import { createConnection } from "mysql2";import { Duration, Effect, Pool } from "effect"
const acquireDBConnection = Effect.acquireRelease( Effect.sync(() => createConnection('mysql://...')), (connection) => Effect.sync(() => connection.end(() => {})),)
const connectionPool = Effect.flatMap( Pool.makeWithTTL({ acquire: acquireDBConnection, min: 10, max: 20, timeToLive: Duration.seconds(60) }), (pool) => pool.get)Getters
Retrieves an item from the pool in a scoped effect. Note that if acquisition fails, then the returned effect will fail for that same reason. Retrying a failed acquisition attempt will repeat the acquisition attempt.
Signature
declare const get: <A, E>(self: Pool<A, E>) => Effect.Effect<A, E, Scope.Scope>Models
A Pool<A, E> is a pool of items of type A, each of which may be
associated with the acquisition and release of resources. An attempt to get
an item A from a pool may fail with an error of type E.
Signature
interface Pool<in out A, out E = never> extends Variance<A, E>, Effect<A, E, Scope.Scope>, Pipeable { readonly [ignoreSymbol]?: PoolUnifyIgnore; readonly [typeSymbol]?: unknown; readonly [unifySymbol]?: PoolUnify<Pool<A, E>>; readonly get: Effect<A, E, Scope>; invalidate(item: A): Effect<void>;}Signature
interface PoolUnify<A extends { [typeSymbol]?: any;}> extends EffectUnify<A> { Pool?: () => Extract<A[typeof typeSymbol], Pool<any, any>> extends Pool<A0, _E0> | _ ? A0 extends any ? Extract<A[typeof typeSymbol], Pool<A0, any>> extends Pool<A0, E1> ? Pool<A0, E1> : never : never : never;}PoolUnifyIgnore interface
Signature
interface PoolUnifyIgnore extends EffectUnifyIgnore { Effect?: true;}Other
Refinements
Symbols
PoolTypeId
Signature
declare const PoolTypeId: unique symbolPoolTypeId type
Signature
type PoolTypeId = typeof PoolTypeId