Skip to content
Effect 4.0 is here. One ecosystem. Zero dependencies.

Pool

11 exports Since v2.0.0 Source

Combinators

invalidate

Since v2.0.0

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

make

Since v2.0.0

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

Since v2.0.0

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

get

Since v2.0.0

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

Pool

interface
Since v2.0.0

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>;
}

PoolUnify

interface
Since v3.9.0

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
Since v3.9.0

Signature

interface PoolUnifyIgnore extends EffectUnifyIgnore {
  Effect?: true;
}

Other

Pool

Since v2.0.0

Refinements

isPool

Since v2.0.0

Returns true if the specified value is a Pool, false otherwise.

Signature

declare const isPool: (u: unknown) => u is Pool<unknown, unknown>

Symbols

PoolTypeId

Since v2.0.0

Signature

declare const PoolTypeId: unique symbol

PoolTypeId

type
Since v2.0.0

Signature

type PoolTypeId = typeof PoolTypeId