<A>(order: Order<A>): (
iterable: Iterable<A>
) => Effect.Effect<TxPriorityQueue<A>>
<A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<
TxPriorityQueue<A>
>Creates a TxPriorityQueue from an iterable of elements.
Example (Creating a priority queue from an iterable)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.fromIterable(Order.Number, [3, 1, 2])
const first = yield* TxPriorityQueue.take(pq)
console.log(first) // 1
})constructors
Source effect/TxPriorityQueue.ts:14413 lines
export const const fromIterable: {
<A>(order: Order<A>): (
iterable: Iterable<A>
) => Effect.Effect<TxPriorityQueue<A>>
<A>(
order: Order<A>,
iterable: Iterable<A>
): Effect.Effect<TxPriorityQueue<A>>
}
Creates a TxPriorityQueue from an iterable of elements.
Example (Creating a priority queue from an iterable)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.fromIterable(Order.Number, [3, 1, 2])
const first = yield* TxPriorityQueue.take(pq)
console.log(first) // 1
})
fromIterable: {
<function (type parameter) A in <A>(order: Order<A>): (iterable: Iterable<A>) => Effect.Effect<TxPriorityQueue<A>>A>(order: Order<A>order: import OrderOrder<function (type parameter) A in <A>(order: Order<A>): (iterable: Iterable<A>) => Effect.Effect<TxPriorityQueue<A>>A>): (iterable: Iterable<A>iterable: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(order: Order<A>): (iterable: Iterable<A>) => Effect.Effect<TxPriorityQueue<A>>A>) => import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<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>(order: Order<A>): (iterable: Iterable<A>) => Effect.Effect<TxPriorityQueue<A>>A>>
<function (type parameter) A in <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>(order: Order<A>order: import OrderOrder<function (type parameter) A in <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>, iterable: Iterable<A>iterable: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<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>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>>
} = import dualdual(
2,
<function (type parameter) A in <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>(order: Order<A>order: import OrderOrder<function (type parameter) A in <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>, iterable: Iterable<A>iterable: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<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>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>> => {
const const arr: A[]arr = var Array: ArrayConstructorArray.ArrayConstructor.from<A>(iterable: Iterable<A> | ArrayLike<A>): A[] (+3 overloads)Creates an array from an iterable object.
from(iterable: Iterable<A>iterable).Array<A>.sort(compareFn?: ((a: A, b: A) => number) | undefined): A[]Sorts an array in place.
This method mutates the array and returns a reference to the same array.
sort((a: Aa, b: Ab) => order: Order<A>order(a: Aa, b: Ab))
return import EffectEffect.map(
import TxRefTxRef.const make: <Chunk<A>>(initial: Chunk<A>) => anyCreates a new TxRef with the specified initial value.
When to use
Use to create a TxRef inside an Effect workflow.
Example (Creating transactional references)
import { Effect, TxRef } from "effect"
const program = Effect.gen(function*() {
// Create a transactional reference with initial value
const counter = yield* TxRef.make(0)
const name = yield* TxRef.make("Alice")
// Use in transactions
yield* Effect.tx(Effect.gen(function*() {
yield* TxRef.set(counter, 42)
yield* TxRef.set(name, "Bob")
}))
console.log(yield* TxRef.get(counter)) // 42
console.log(yield* TxRef.get(name)) // "Bob"
})
make<import ChunkChunk<function (type parameter) A in <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>A>>(import CC.fromIterable(const arr: A[]arr)),
(ref: TxRef.TxRef<Chunk<A>>(parameter) 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; <…;
}
const makeTxPriorityQueue: <A>(
ref: TxRef.TxRef<Chunk<A>>,
ord: Order<A>
) => TxPriorityQueue<A>
ref: TxRef.TxRef<Chunk<A>>(parameter) 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; <…;
}
order: Order<A>order)
)
}
)Referenced by 1 symbols