effect 2.0.0-next.44 → 2.0.0-next.46

package/src/TPriorityQueue.ts

@@ -0,0 +1,223 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/stm/tPriorityQueue"
+import type * as Option from "./Option"
+import type * as Order from "./Order"
+import type { Predicate } from "./Predicate"
+import type * as SortedMap from "./SortedMap"
+import type * as STM from "./STM"
+import type * as TRef from "./TRef"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const TPriorityQueueTypeId: unique symbol = internal.TPriorityQueueTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type TPriorityQueueTypeId = typeof TPriorityQueueTypeId
+
+/**
+ * A `TPriorityQueue` contains values of type `A` that an `Order` is defined
+ * on. Unlike a `TQueue`, `take` returns the highest priority value (the value
+ * that is first in the specified ordering) as opposed to the first value
+ * offered to the queue. The ordering that elements with the same priority will
+ * be taken from the queue is not guaranteed.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface TPriorityQueue<A> extends TPriorityQueue.Variance<A> {}
+/**
+ * @internal
+ * @since 2.0.0
+ */
+export interface TPriorityQueue<A> {
+  /** @internal */
+  readonly ref: TRef.TRef<SortedMap.SortedMap<A, [A, ...Array<A>]>>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace TPriorityQueue {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<A> {
+    readonly [TPriorityQueueTypeId]: {
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * Constructs a new empty `TPriorityQueue` with the specified `Order`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: <A>(order: Order.Order<A>) => STM.STM<never, never, TPriorityQueue<A>> = internal.empty
+
+/**
+ * Makes a new `TPriorityQueue` initialized with provided iterable.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: <A>(
+  order: Order.Order<A>
+) => (iterable: Iterable<A>) => STM.STM<never, never, TPriorityQueue<A>> = internal.fromIterable
+
+/**
+ * Checks whether the queue is empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, boolean> = internal.isEmpty
+
+/**
+ * Checks whether the queue is not empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isNonEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, boolean> = internal.isNonEmpty
+
+/**
+ * Makes a new `TPriorityQueue` that is initialized with specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <A>(order: Order.Order<A>) => (...elements: Array<A>) => STM.STM<never, never, TPriorityQueue<A>> =
+  internal.make
+
+/**
+ * Offers the specified value to the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const offer: {
+  <A>(value: A): (self: TPriorityQueue<A>) => STM.STM<never, never, void>
+  <A>(self: TPriorityQueue<A>, value: A): STM.STM<never, never, void>
+} = internal.offer
+
+/**
+ * Offers all of the elements in the specified collection to the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const offerAll: {
+  <A>(values: Iterable<A>): (self: TPriorityQueue<A>) => STM.STM<never, never, void>
+  <A>(self: TPriorityQueue<A>, values: Iterable<A>): STM.STM<never, never, void>
+} = internal.offerAll
+
+/**
+ * Peeks at the first value in the queue without removing it, retrying until a
+ * value is in the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const peek: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, A> = internal.peek
+
+/**
+ * Peeks at the first value in the queue without removing it, returning `None`
+ * if there is not a value in the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const peekOption: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Option.Option<A>> = internal.peekOption
+
+/**
+ * Removes all elements from the queue matching the specified predicate.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const removeIf: {
+  <A>(predicate: Predicate<A>): (self: TPriorityQueue<A>) => STM.STM<never, never, void>
+  <A>(self: TPriorityQueue<A>, predicate: Predicate<A>): STM.STM<never, never, void>
+} = internal.removeIf
+
+/**
+ * Retains only elements from the queue matching the specified predicate.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const retainIf: {
+  <A>(predicate: Predicate<A>): (self: TPriorityQueue<A>) => STM.STM<never, never, void>
+  <A>(self: TPriorityQueue<A>, predicate: Predicate<A>): STM.STM<never, never, void>
+} = internal.retainIf
+
+/**
+ * Returns the size of the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, number> = internal.size
+
+/**
+ * Takes a value from the queue, retrying until a value is in the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const take: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, A> = internal.take
+
+/**
+ * Takes all values from the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const takeAll: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Array<A>> = internal.takeAll
+
+/**
+ * Takes a value from the queue, returning `None` if there is not a value in
+ * the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const takeOption: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Option.Option<A>> = internal.takeOption
+
+/**
+ * Takes up to the specified maximum number of elements from the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const takeUpTo: {
+  (n: number): <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Array<A>>
+  <A>(self: TPriorityQueue<A>, n: number): STM.STM<never, never, Array<A>>
+} = internal.takeUpTo
+
+/**
+ * Collects all values into a chunk.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toArray: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, Array<A>> = internal.toChunk
+
+/**
+ * Collects all values into an array.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadonlyArray: <A>(self: TPriorityQueue<A>) => STM.STM<never, never, ReadonlyArray<A>> =
+  internal.toReadonlyArray

package/src/TPubSub.ts

@@ -0,0 +1,187 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect"
+import type * as HashSet from "./HashSet"
+import * as internal from "./internal/stm/tPubSub"
+import type * as tQueue from "./internal/stm/tQueue"
+import type * as Scope from "./Scope"
+import type * as STM from "./STM"
+import type * as TQueue from "./TQueue"
+import type * as TRef from "./TRef"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const TPubSubTypeId: unique symbol = internal.TPubSubTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type TPubSubTypeId = typeof TPubSubTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface TPubSub<A> extends TQueue.TEnqueue<A> {}
+/**
+ * @internal
+ * @since 2.0.0
+ */
+export interface TPubSub<A> {
+  readonly [TPubSubTypeId]: TPubSubTypeId
+  /** @internal */
+  readonly pubsubSize: TRef.TRef<number>
+  /** @internal */
+  readonly publisherHead: TRef.TRef<TRef.TRef<internal.Node<A> | undefined>>
+  /** @internal */
+  readonly publisherTail: TRef.TRef<TRef.TRef<internal.Node<A> | undefined> | undefined>
+  /** @internal */
+  readonly requestedCapacity: number
+  /** @internal */
+  readonly strategy: tQueue.TQueueStrategy
+  /** @internal */
+  readonly subscriberCount: TRef.TRef<number>
+  /** @internal */
+  readonly subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<internal.Node<A>> | undefined>>>
+}
+
+/**
+ * Waits until the `TPubSub` is shutdown. The `STM` returned by this method will
+ * not resume until the queue has been shutdown. If the `TPubSub` is already
+ * shutdown, the `STM` will resume right away.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const awaitShutdown: <A>(self: TPubSub<A>) => STM.STM<never, never, void> = internal.awaitShutdown
+
+/**
+ * Creates a bounded `TPubSub` with the back pressure strategy. The `TPubSub` will retain
+ * messages until they have been taken by all subscribers, applying back
+ * pressure to publishers if the `TPubSub` is at capacity.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const bounded: <A>(requestedCapacity: number) => STM.STM<never, never, TPubSub<A>> = internal.bounded
+
+/**
+ * Returns the number of elements the `TPubSub` can hold.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const capacity: <A>(self: TPubSub<A>) => number = internal.capacity
+
+/**
+ * Creates a bounded `TPubSub` with the dropping strategy. The `TPubSub` will drop new
+ * messages if the `TPubSub` is at capacity.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const dropping: <A>(requestedCapacity: number) => STM.STM<never, never, TPubSub<A>> = internal.dropping
+
+/**
+ * Returns `true` if the `TPubSub` contains zero elements, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isEmpty: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean> = internal.isEmpty
+
+/**
+ * Returns `true` if the `TPubSub` contains at least one element, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isFull: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean> = internal.isFull
+
+/**
+ * Returns `true` if `shutdown` has been called, otherwise returns `false`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isShutdown: <A>(self: TPubSub<A>) => STM.STM<never, never, boolean> = internal.isShutdown
+
+/**
+ * Publishes a message to the `TPubSub`, returning whether the message was published
+ * to the `TPubSub`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const publish: {
+  <A>(value: A): (self: TPubSub<A>) => STM.STM<never, never, boolean>
+  <A>(self: TPubSub<A>, value: A): STM.STM<never, never, boolean>
+} = internal.publish
+
+/**
+ * Publishes all of the specified messages to the `TPubSub`, returning whether they
+ * were published to the `TPubSub`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const publishAll: {
+  <A>(iterable: Iterable<A>): (self: TPubSub<A>) => STM.STM<never, never, boolean>
+  <A>(self: TPubSub<A>, iterable: Iterable<A>): STM.STM<never, never, boolean>
+} = internal.publishAll
+
+/**
+ * Retrieves the size of the `TPubSub`, which is equal to the number of elements
+ * in the `TPubSub`. This may be negative if fibers are suspended waiting for
+ * elements to be added to the `TPubSub`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size: <A>(self: TPubSub<A>) => STM.STM<never, never, number> = internal.size
+
+/**
+ * Creates a bounded `TPubSub` with the sliding strategy. The `TPubSub` will add new
+ * messages and drop old messages if the `TPubSub` is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const sliding: <A>(requestedCapacity: number) => STM.STM<never, never, TPubSub<A>> = internal.sliding
+
+/**
+ * Subscribes to receive messages from the `TPubSub`. The resulting subscription can
+ * be evaluated multiple times to take a message from the `TPubSub` each time. The
+ * caller is responsible for unsubscribing from the `TPubSub` by shutting down the
+ * queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const subscribe: <A>(self: TPubSub<A>) => STM.STM<never, never, TQueue.TDequeue<A>> = internal.subscribe
+
+/**
+ * Subscribes to receive messages from the `TPubSub`. The resulting subscription can
+ * be evaluated multiple times within the scope to take a message from the `TPubSub`
+ * each time.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const subscribeScoped: <A>(self: TPubSub<A>) => Effect.Effect<Scope.Scope, never, TQueue.TDequeue<A>> =
+  internal.subscribeScoped
+
+/**
+ * Creates an unbounded `TPubSub`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unbounded: <A>() => STM.STM<never, never, TPubSub<A>> = internal.unbounded