Enqueue<A, E>An Enqueue is a queue that can be offered to.
Details
This interface represents the write-only part of a Queue, allowing you to offer elements to the queue but not take elements from it.
Example (Offering through enqueue handles)
import { Effect, Queue } from "effect"
// Function that only needs write access to a queue
const producer = (enqueue: Queue.Enqueue<string>) =>
Effect.gen(function*() {
yield* Queue.offer(enqueue, "hello")
yield* Queue.offerAll(enqueue, ["world", "!"])
})
const program = Effect.gen(function*() {
const queue = yield* Queue.bounded<string>(10)
yield* producer(queue)
})export interface interface Enqueue<in A, in E = never>An Enqueue is a queue that can be offered to.
Details
This interface represents the write-only part of a Queue, allowing you to offer
elements to the queue but not take elements from it.
Example (Offering through enqueue handles)
import { Effect, Queue } from "effect"
// Function that only needs write access to a queue
const producer = (enqueue: Queue.Enqueue<string>) =>
Effect.gen(function*() {
yield* Queue.offer(enqueue, "hello")
yield* Queue.offerAll(enqueue, ["world", "!"])
})
const program = Effect.gen(function*() {
const queue = yield* Queue.bounded<string>(10)
yield* producer(queue)
})
Companion namespace containing type-level metadata for the Enqueue
write-only queue interface.
Enqueue<in function (type parameter) A in Enqueue<in A, in E = never>A, in function (type parameter) E in Enqueue<in A, in E = never>E = never> extends import InspectableInspectable {
readonly [const EnqueueTypeId: "~effect/Queue/Enqueue"EnqueueTypeId]: Enqueue.interface Enqueue<in A, in E = never>.Variance<A, E>Type-level variance marker for Enqueue.
Details
Enqueue is contravariant in both its offered value type A and failure
type E, because values and failures flow into the queue through this
handle.
Variance<function (type parameter) A in Enqueue<in A, in E = never>A, function (type parameter) E in Enqueue<in A, in E = never>E>
readonly Enqueue<in A, in E = never>.strategy: "suspend" | "dropping" | "sliding"strategy: "suspend" | "dropping" | "sliding"
readonly Enqueue<in A, in E = never>.dispatcher: SchedulerDispatcher(property) Enqueue<in A, in E = never>.dispatcher: {
scheduleTask: (task: () => void, priority: number) => void;
flush: () => void;
}
Enqueue<in A, in E = never>.capacity: numbercapacity: number
Enqueue<in A, in E = never>.messages: MutableList.MutableList<any>(property) Enqueue<in A, in E = never>.messages: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
import MutableListMutableList.type MutableList.MutableList = /*unresolved*/ anyMutableList<any>
Enqueue<in A, in 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>
Enqueue<in A, in E = never>.scheduleRunning: booleanscheduleRunning: boolean
}
/**
* Companion namespace containing type-level metadata for the `Enqueue`
* write-only queue interface.
*
* @since 2.0.0
*/
export declare namespace Enqueue {
/**
* Type-level variance marker for `Enqueue`.
*
* **Details**
*
* `Enqueue` is contravariant in both its offered value type `A` and failure
* type `E`, because values and failures flow into the queue through this
* handle.
*
* @category models
* @since 4.0.0
*/
export interface interface Enqueue<in A, in E = never>.Variance<A, E>Type-level variance marker for Enqueue.
Details
Enqueue is contravariant in both its offered value type A and failure
type E, because values and failures flow into the queue through this
handle.
Variance<function (type parameter) A in Variance<A, E>A, function (type parameter) E in Variance<A, E>E> {
Enqueue<in A, in E = never>.Variance<A, E>._A: Types.Contravariant<A>_A: import TypesTypes.type Contravariant<A> = (_: A) => voidFunction-type alias encoding contravariant variance for a phantom type
parameter.
When to use
Use as a phantom field type to make a type parameter contravariant in input
position.
Details
Contravariant<A> is assignable to Contravariant<B> when B extends A,
following the supertype direction.
Example (Defining a contravariant phantom type)
import type { Types } from "effect"
interface Consumer<T> {
readonly _phantom: Types.Contravariant<T>
readonly accept: (value: T) => void
}
Namespace for
Contravariant
-related utilities.
When to use
Use when referring to type-level helpers nested under Contravariant.
Contravariant<function (type parameter) A in Variance<A, E>A>
Enqueue<in A, in E = never>.Variance<A, E>._E: Types.Contravariant<E>_E: import TypesTypes.type Contravariant<A> = (_: A) => voidFunction-type alias encoding contravariant variance for a phantom type
parameter.
When to use
Use as a phantom field type to make a type parameter contravariant in input
position.
Details
Contravariant<A> is assignable to Contravariant<B> when B extends A,
following the supertype direction.
Example (Defining a contravariant phantom type)
import type { Types } from "effect"
interface Consumer<T> {
readonly _phantom: Types.Contravariant<T>
readonly accept: (value: T) => void
}
Namespace for
Contravariant
-related utilities.
When to use
Use when referring to type-level helpers nested under Contravariant.
Contravariant<function (type parameter) E in Variance<A, E>E>
}
}