Dequeue<A, E>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"
})export interface 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<out function (type parameter) A in Dequeue<out A, out E = never>A, out function (type parameter) E in Dequeue<out A, out E = never>E = never> extends import InspectableInspectable {
readonly [const DequeueTypeId: "~effect/Queue/Dequeue"DequeueTypeId]: Dequeue.interface Dequeue<out A, out E = never>.Variance<A, E>Type-level variance marker for Dequeue.
Details
Dequeue is covariant in both the taken value type A and failure type
E, because values and failures are observed through this handle.
Variance<function (type parameter) A in Dequeue<out A, out E = never>A, function (type parameter) E in Dequeue<out A, out E = never>E>
readonly Dequeue<out A, out E = never>.strategy: "suspend" | "dropping" | "sliding"strategy: "suspend" | "dropping" | "sliding"
readonly Dequeue<out A, out E = never>.dispatcher: SchedulerDispatcher(property) Dequeue<out A, out E = never>.dispatcher: {
scheduleTask: (task: () => void, priority: number) => void;
flush: () => void;
}
Dequeue<out A, out E = never>.capacity: numbercapacity: number
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;
}
import MutableListMutableList.type MutableList.MutableList = /*unresolved*/ anyMutableList<any>
Dequeue<out A, out E = never>.state: Queue.State<any, any>state: Queue.type Queue<in out A, in out E = never>.State<A, E> = {
readonly _tag: "Open";
readonly takers: Set<(_: Effect<void, E>) => void>;
readonly offers: Set<Queue.OfferEntry<A>>;
readonly awaiters: Set<(_: Effect<void, E>) => void>;
} | {
readonly _tag: "Closing";
readonly takers: Set<(_: Effect<void, E>) => void>;
readonly offers: Set<Queue.OfferEntry<A>>;
readonly awaiters: Set<(_: Effect<void, E>) => void>;
readonly exit: Failure<never, E>;
} | {
readonly _tag: "Done";
readonly exit: Failure<never, E>;
}
Tagged state of a Queue.
Details
Open queues can accept offers and takers, Closing queues are
completing with a stored failure exit, and Done queues have finished.
This is low-level metadata exposed by the queue model; most users should
inspect queues through the public operations.
State<any, any>
Dequeue<out A, out E = never>.scheduleRunning: booleanscheduleRunning: boolean
}
/**
* Companion namespace containing type-level metadata for the `Dequeue`
* read-only queue interface.
*
* @since 2.0.0
*/
export declare namespace Dequeue {
/**
* Type-level variance marker for `Dequeue`.
*
* **Details**
*
* `Dequeue` is covariant in both the taken value type `A` and failure type
* `E`, because values and failures are observed through this handle.
*
* @category models
* @since 4.0.0
*/
export interface interface Dequeue<out A, out E = never>.Variance<A, E>Type-level variance marker for Dequeue.
Details
Dequeue is covariant in both the taken value type A and failure type
E, because values and failures are observed through this handle.
Variance<function (type parameter) A in Variance<A, E>A, function (type parameter) E in Variance<A, E>E> {
Dequeue<out A, out E = never>.Variance<A, E>._A: Types.Covariant<A>_A: import TypesTypes.type Covariant<A> = (_: never) => AFunction-type alias encoding covariant variance for a phantom type
parameter.
When to use
Use as a phantom field type to make a type parameter covariant in output
position.
Details
Covariant<A> is assignable to Covariant<B> when A extends B, following
the subtype direction.
Example (Defining a covariant phantom type)
import type { Types } from "effect"
interface Producer<T> {
readonly _phantom: Types.Covariant<T>
readonly get: () => T
}
Namespace for
Covariant
-related utilities.
When to use
Use when referring to type-level helpers nested under Covariant.
Covariant<function (type parameter) A in Variance<A, E>A>
Dequeue<out A, out E = never>.Variance<A, E>._E: Types.Covariant<E>_E: import TypesTypes.type Covariant<A> = (_: never) => AFunction-type alias encoding covariant variance for a phantom type
parameter.
When to use
Use as a phantom field type to make a type parameter covariant in output
position.
Details
Covariant<A> is assignable to Covariant<B> when A extends B, following
the subtype direction.
Example (Defining a covariant phantom type)
import type { Types } from "effect"
interface Producer<T> {
readonly _phantom: Types.Covariant<T>
readonly get: () => T
}
Namespace for
Covariant
-related utilities.
When to use
Use when referring to type-level helpers nested under Covariant.
Covariant<function (type parameter) E in Variance<A, E>E>
}
}