Pool
Combinators
invalidate
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".
```ts skip-type-checking 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 ) ```
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>;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 symbol;PoolTypeId type
Signature
type PoolTypeId = typeof PoolTypeId;
Invalidates the specified item. This will cause the pool to eventually reallocate the item, although this reallocation may occur lazily rather than eagerly.