<A>(values: Iterable<A>): (
self: TxPriorityQueue<A>
) => Effect.Effect<void>
<A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void>Inserts all elements from an iterable into the queue.
Example (Offering multiple values)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.empty<number>(Order.Number)
yield* TxPriorityQueue.offerAll(pq, [3, 1, 2])
const first = yield* TxPriorityQueue.take(pq)
console.log(first) // 1
})mutations
Source effect/TxPriorityQueue.ts:34611 lines
export const const offerAll: {
<A>(values: Iterable<A>): (
self: TxPriorityQueue<A>
) => Effect.Effect<void>
<A>(
self: TxPriorityQueue<A>,
values: Iterable<A>
): Effect.Effect<void>
}
Inserts all elements from an iterable into the queue.
Example (Offering multiple values)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.empty<number>(Order.Number)
yield* TxPriorityQueue.offerAll(pq, [3, 1, 2])
const first = yield* TxPriorityQueue.take(pq)
console.log(first) // 1
})
offerAll: {
<function (type parameter) A in <A>(values: Iterable<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void>A>(values: Iterable<A>values: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(values: Iterable<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void>A>): (self: TxPriorityQueue<A>(parameter) self: {
ref: TxRef.TxRef<Chunk<A>>;
ord: Order<A>;
toString: () => string;
toJSON: () => unknown;
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; <…;
}
interface TxPriorityQueue<in out A>A transactional priority queue backed by a sorted Chunk.
Details
Elements are stored in ascending order according to the Order provided at
construction time. take returns the smallest element, peek observes it
without removing.
Example (Dequeuing values by priority)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.empty<number>(Order.Number)
yield* TxPriorityQueue.offer(pq, 3)
yield* TxPriorityQueue.offer(pq, 1)
yield* TxPriorityQueue.offer(pq, 2)
const first = yield* TxPriorityQueue.take(pq)
console.log(first) // 1
})
TxPriorityQueue<function (type parameter) A in <A>(values: Iterable<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void>A>) => import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<void>
<function (type parameter) A in <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void>A>(self: TxPriorityQueue<A>(parameter) self: {
ref: TxRef.TxRef<Chunk<A>>;
ord: Order<A>;
toString: () => string;
toJSON: () => unknown;
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; <…;
}
interface TxPriorityQueue<in out A>A transactional priority queue backed by a sorted Chunk.
Details
Elements are stored in ascending order according to the Order provided at
construction time. take returns the smallest element, peek observes it
without removing.
Example (Dequeuing values by priority)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.empty<number>(Order.Number)
yield* TxPriorityQueue.offer(pq, 3)
yield* TxPriorityQueue.offer(pq, 1)
yield* TxPriorityQueue.offer(pq, 2)
const first = yield* TxPriorityQueue.take(pq)
console.log(first) // 1
})
TxPriorityQueue<function (type parameter) A in <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void>A>, values: Iterable<A>values: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void>A>): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<void>
} = import dualdual(
2,
<function (type parameter) A in <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void>A>(self: TxPriorityQueue<A>(parameter) self: {
ref: TxRef.TxRef<Chunk<A>>;
ord: Order<A>;
toString: () => string;
toJSON: () => unknown;
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; <…;
}
interface TxPriorityQueue<in out A>A transactional priority queue backed by a sorted Chunk.
Details
Elements are stored in ascending order according to the Order provided at
construction time. take returns the smallest element, peek observes it
without removing.
Example (Dequeuing values by priority)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.empty<number>(Order.Number)
yield* TxPriorityQueue.offer(pq, 3)
yield* TxPriorityQueue.offer(pq, 1)
yield* TxPriorityQueue.offer(pq, 2)
const first = yield* TxPriorityQueue.take(pq)
console.log(first) // 1
})
TxPriorityQueue<function (type parameter) A in <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void>A>, values: Iterable<A>values: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void>A>): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<void> =>
import TxRefTxRef.const update: {
<A>(f: (current: NoInfer<A>) => A): (
self: TxRef<A>
) => Effect.Effect<void>
<A>(
self: TxRef<A>,
f: (current: A) => A
): Effect.Effect<void>
}
self: TxPriorityQueue<A>(parameter) self: {
ref: TxRef.TxRef<Chunk<A>>;
ord: Order<A>;
toString: () => string;
toJSON: () => unknown;
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; <…;
}
TxPriorityQueue<in out A>.ref: TxRef.TxRef<Chunk<A>>(property) TxPriorityQueue<in out A>.ref: {
version: number;
pending: Map<unknown, () => void>;
value: A;
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; <…;
}
chunk: Chunk<A>(parameter) chunk: {
length: number;
right: Chunk<A>;
left: Chunk<A>;
backing: Backing<A>;
depth: number;
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;
}
const arr: any[]arr = [...import CC.toArray(chunk: Chunk<A>(parameter) chunk: {
length: number;
right: Chunk<A>;
left: Chunk<A>;
backing: Backing<A>;
depth: number;
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;
}
values: Iterable<A>values].Array<any>.sort(compareFn?: ((a: any, b: any) => number) | undefined): any[]Sorts an array in place.
This method mutates the array and returns a reference to the same array.
sort((a: anya, b: anyb) => self: TxPriorityQueue<A>(parameter) self: {
ref: TxRef.TxRef<Chunk<A>>;
ord: Order<A>;
toString: () => string;
toJSON: () => unknown;
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; <…;
}
TxPriorityQueue<in out A>.ord: Order<A>ord(a: anya, b: anyb))
return import CC.fromIterable(const arr: any[]arr)
})
)