<A, E>(self: Dequeue<A, E>): Effect<A, E>Takes a single message from the queue, or wait for a message to be available.
Details
If the queue is done, it will fail with Done. If the
queue fails, the Effect will fail with the error.
Example (Taking one value)
import { Cause, Effect, Queue } from "effect"
const program = Effect.gen(function*() {
const queue = yield* Queue.bounded<string, Cause.Done>(3)
// Add some messages
yield* Queue.offer(queue, "first")
yield* Queue.offer(queue, "second")
// Take messages one by one
const msg1 = yield* Queue.take(queue)
const msg2 = yield* Queue.take(queue)
console.log(msg1, msg2) // "first", "second"
// End the queue
yield* Queue.end(queue)
// Taking from an ended queue fails with Done
const result = yield* Effect.match(Queue.take(queue), {
onFailure: (error: Cause.Done) => true,
onSuccess: (value: string) => false
})
console.log("Queue ended:", result) // true
})taking
Source effect/Queue.ts:13964 lines
export const const take: <A, E>(
self: Dequeue<A, E>
) => Effect<A, E>
Takes a single message from the queue, or wait for a message to be
available.
Details
If the queue is done, it will fail with Done. If the
queue fails, the Effect will fail with the error.
Example (Taking one value)
import { Cause, Effect, Queue } from "effect"
const program = Effect.gen(function*() {
const queue = yield* Queue.bounded<string, Cause.Done>(3)
// Add some messages
yield* Queue.offer(queue, "first")
yield* Queue.offer(queue, "second")
// Take messages one by one
const msg1 = yield* Queue.take(queue)
const msg2 = yield* Queue.take(queue)
console.log(msg1, msg2) // "first", "second"
// End the queue
yield* Queue.end(queue)
// Taking from an ended queue fails with Done
const result = yield* Effect.match(Queue.take(queue), {
onFailure: (error: Cause.Done) => true,
onSuccess: (value: string) => false
})
console.log("Queue ended:", result) // true
})
take = <function (type parameter) A in <A, E>(self: Dequeue<A, E>): Effect<A, E>A, function (type parameter) E in <A, E>(self: Dequeue<A, E>): Effect<A, E>E>(self: Dequeue<A, E>(parameter) self: {
strategy: "suspend" | "dropping" | "sliding";
dispatcher: SchedulerDispatcher;
capacity: number;
messages: MutableList.MutableList<any>;
state: Queue.State<any, any>;
scheduleRunning: boolean;
toString: () => string;
toJSON: () => unknown;
}
interface Dequeue<out A, out E = never>A Dequeue is a queue that can be taken from.
Details
This interface represents the read-only part of a Queue, allowing you to take
elements from the queue but not offer elements to it.
Example (Taking through dequeue handles)
import { Effect, Queue } from "effect"
const program = Effect.gen(function*() {
const queue = yield* Queue.bounded<string, never>(10)
// A Dequeue can only take elements
const dequeue: Queue.Dequeue<string> = queue
// Pre-populate the queue
yield* Queue.offerAll(queue, ["a", "b", "c"])
// Take elements using dequeue interface
const item = yield* Queue.take(dequeue)
console.log(item) // "a"
})
Companion namespace containing type-level metadata for the Dequeue
read-only queue interface.
Dequeue<function (type parameter) A in <A, E>(self: Dequeue<A, E>): Effect<A, E>A, function (type parameter) E in <A, E>(self: Dequeue<A, E>): Effect<A, E>E>): import EffectEffect<function (type parameter) A in <A, E>(self: Dequeue<A, E>): Effect<A, E>A, function (type parameter) E in <A, E>(self: Dequeue<A, E>): Effect<A, E>E> =>
import internalEffectinternalEffect.const suspend: <A, E, R>(
evaluate: LazyArg<Effect.Effect<A, E, R>>
) => Effect.Effect<A, E, R>
const takeUnsafe: <A, E>(
self: Dequeue<A, E>
) => Exit<A, E> | undefined
Attempts to take one message from the queue synchronously.
When to use
Use when polling queue internals must not suspend or register a waiting taker,
and undefined is an acceptable result for an empty queue.
Details
Returns an Exit for an immediately available message or for the queue's
terminal state. Returns undefined when no message is immediately available.
This operation does not wait or register a taker.
Example (Taking one value synchronously)
import { Effect, Queue } from "effect"
// Create a queue and use unsafe operations
const program = Effect.gen(function*() {
const queue = yield* Queue.bounded<number>(10)
// Add some messages
Queue.offerUnsafe(queue, 1)
Queue.offerUnsafe(queue, 2)
// Take a message synchronously
const result1 = Queue.takeUnsafe(queue)
console.log(result1) // Success(1) or Exit containing value 1
const result2 = Queue.takeUnsafe(queue)
console.log(result2) // Success(2)
// No more messages - returns undefined
const result3 = Queue.takeUnsafe(queue)
console.log(result3) // undefined
})
takeUnsafe(self: Dequeue<A, E>(parameter) self: {
strategy: "suspend" | "dropping" | "sliding";
dispatcher: SchedulerDispatcher;
capacity: number;
messages: MutableList.MutableList<any>;
state: Queue.State<any, any>;
scheduleRunning: boolean;
toString: () => string;
toJSON: () => unknown;
}
import internalEffectinternalEffect.const andThen: {
<A, B, E2, R2>(
f: (a: A) => Effect.Effect<B, E2, R2>
): <E, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<B, E | E2, R | R2>
<B, E2, R2>(f: Effect.Effect<B, E2, R2>): <
A,
E,
R
>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<B, E | E2, R | R2>
<A, E, R, B, E2, R2>(
self: Effect.Effect<A, E, R>,
f: (a: A) => Effect.Effect<B, E2, R2>
): Effect.Effect<B, E | E2, R | R2>
<A, E, R, B, E2, R2>(
self: Effect.Effect<A, E, R>,
f: Effect.Effect<B, E2, R2>
): Effect.Effect<B, E | E2, R | R2>
}
const awaitTake: <A, E>(
self: Dequeue<A, E>
) => Effect<void, E, never>
self: Dequeue<A, E>(parameter) self: {
strategy: "suspend" | "dropping" | "sliding";
dispatcher: SchedulerDispatcher;
capacity: number;
messages: MutableList.MutableList<any>;
state: Queue.State<any, any>;
scheduleRunning: boolean;
toString: () => string;
toJSON: () => unknown;
}
const take: <A, E>(
self: Dequeue<A, E>
) => Effect<A, E>
Takes a single message from the queue, or wait for a message to be
available.
Details
If the queue is done, it will fail with Done. If the
queue fails, the Effect will fail with the error.
Example (Taking one value)
import { Cause, Effect, Queue } from "effect"
const program = Effect.gen(function*() {
const queue = yield* Queue.bounded<string, Cause.Done>(3)
// Add some messages
yield* Queue.offer(queue, "first")
yield* Queue.offer(queue, "second")
// Take messages one by one
const msg1 = yield* Queue.take(queue)
const msg2 = yield* Queue.take(queue)
console.log(msg1, msg2) // "first", "second"
// End the queue
yield* Queue.end(queue)
// Taking from an ended queue fails with Done
const result = yield* Effect.match(Queue.take(queue), {
onFailure: (error: Cause.Done) => true,
onSuccess: (value: string) => false
})
console.log("Queue ended:", result) // true
})
take(self: Dequeue<A, E>(parameter) self: {
strategy: "suspend" | "dropping" | "sliding";
dispatcher: SchedulerDispatcher;
capacity: number;
messages: MutableList.MutableList<any>;
state: Queue.State<any, any>;
scheduleRunning: boolean;
toString: () => string;
toJSON: () => unknown;
}
Referenced by 6 symbols