<A, E>(self: Dequeue<A, E>): Exit<A, E> | undefinedAttempts 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
})taking
Source effect/Queue.ts:152518 lines
export const 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 = <function (type parameter) A in <A, E>(self: Dequeue<A, E>): Exit<A, E> | undefinedA, function (type parameter) E in <A, E>(self: Dequeue<A, E>): Exit<A, E> | undefinedE>(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>): Exit<A, E> | undefinedA, function (type parameter) E in <A, E>(self: Dequeue<A, E>): Exit<A, E> | undefinedE>): import ExitExit<function (type parameter) A in <A, E>(self: Dequeue<A, E>): Exit<A, E> | undefinedA, function (type parameter) E in <A, E>(self: Dequeue<A, E>): Exit<A, E> | undefinedE> | undefined => {
if (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;
}
Dequeue<out A, out E = never>.state: Queue.State<any, any>state._tag: "Open" | "Closing" | "Done"_tag === "Done") {
return 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;
}
Dequeue<out A, out E = never>.state: {
readonly _tag: "Done";
readonly exit: Failure<never, E>;
}
exit: Failure<never, E>(property) exit: {
_tag: "Failure";
cause: Cause.Cause<E>;
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;
}
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;
}
Dequeue<out A, out E = never>.messages: MutableList.MutableList<any>(property) Dequeue<out A, out E = never>.messages: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
const message: anymessage = import MutableListMutableList.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;
}
Dequeue<out A, out E = never>.messages: MutableList.MutableList<any>(property) Dequeue<out A, out E = never>.messages: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
const releaseCapacity: <A, E>(
self: Dequeue<A, E>
) => boolean
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 corecore.const exitSucceed: <A>(
a: A
) => Exit.Exit<A>
const message: anymessage)
} else if (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;
}
Dequeue<out A, out E = never>.capacity: numbercapacity <= 0 && 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;
}
Dequeue<out A, out E = never>.state: {
readonly _tag: "Open";
readonly takers: Set<(_: Effect<void, any>) => void>;
readonly offers: Set<Queue.OfferEntry<any>>;
readonly awaiters: Set<(_: Effect<void, any>) => void>;
} | {
readonly _tag: "Closing";
readonly takers: Set<(_: Effect<void, any>) => void>;
readonly offers: Set<Queue.OfferEntry<any>>;
readonly awaiters: Set<(_: Effect<void, any>) => void>;
readonly exit: Failure<never, E>;
}
offers: Set<Queue.OfferEntry<any>>offers.Set<T>.size: numbersize > 0) {
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;
}
Dequeue<out A, out E = never>.capacity: numbercapacity = 1
const releaseCapacity: <A, E>(
self: Dequeue<A, E>
) => boolean
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;
}
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;
}
Dequeue<out A, out E = never>.capacity: numbercapacity = 0
const const message: anymessage = import MutableListMutableList.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;
}
Dequeue<out A, out E = never>.messages: MutableList.MutableList<any>(property) Dequeue<out A, out E = never>.messages: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
const releaseCapacity: <A, E>(
self: Dequeue<A, E>
) => boolean
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 corecore.const exitSucceed: <A>(
a: A
) => Exit.Exit<A>
const message: anymessage)
}
return var undefinedundefined
}Referenced by 2 symbols