<A>(predicate: Predicate<A>): (
self: TxPriorityQueue<A>
) => Effect.Effect<void>
<A>(
self: TxPriorityQueue<A>,
predicate: Predicate<A>
): Effect.Effect<void>Keeps only elements matching the predicate.
Example (Retaining matching values)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.fromIterable(Order.Number, [1, 2, 3, 4, 5])
yield* TxPriorityQueue.retainIf(pq, (n) => n % 2 === 0)
const all = yield* TxPriorityQueue.takeAll(pq)
console.log(all) // [2, 4]
})filtering
Source effect/TxPriorityQueue.ts:5198 lines
export const const retainIf: {
<A>(predicate: Predicate<A>): (
self: TxPriorityQueue<A>
) => Effect.Effect<void>
<A>(
self: TxPriorityQueue<A>,
predicate: Predicate<A>
): Effect.Effect<void>
}
Keeps only elements matching the predicate.
Example (Retaining matching values)
import { Effect, Order, TxPriorityQueue } from "effect"
const program = Effect.gen(function*() {
const pq = yield* TxPriorityQueue.fromIterable(Order.Number, [1, 2, 3, 4, 5])
yield* TxPriorityQueue.retainIf(pq, (n) => n % 2 === 0)
const all = yield* TxPriorityQueue.takeAll(pq)
console.log(all) // [2, 4]
})
retainIf: {
<function (type parameter) A in <A>(predicate: Predicate<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void>A>(predicate: Predicate<A>predicate: import PredicatePredicate<function (type parameter) A in <A>(predicate: Predicate<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>(predicate: Predicate<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>, predicate: Predicate<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>, predicate: Predicate<A>): Effect.Effect<void>A>, predicate: Predicate<A>predicate: import PredicatePredicate<function (type parameter) A in <A>(self: TxPriorityQueue<A>, predicate: Predicate<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>, predicate: Predicate<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>, predicate: Predicate<A>): Effect.Effect<void>A>, predicate: Predicate<A>predicate: import PredicatePredicate<function (type parameter) A in <A>(self: TxPriorityQueue<A>, predicate: Predicate<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;
}
import CC.filter(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;
}
predicate: Predicate<A>predicate))
)