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

package/src/RedBlackTree.ts

@@ -0,0 +1,415 @@
+/**
+ * @since 2.0.0
+ */
+import type { Chunk } from "./Chunk"
+import type { Equal } from "./Equal"
+import type { Inspectable } from "./Inspectable"
+import * as RBT from "./internal/RedBlackTree"
+import * as RBTI from "./internal/RedBlackTree/iterator"
+import type { Option } from "./Option"
+import type { Order } from "./Order"
+import type { Pipeable } from "./Pipeable"
+
+const TypeId: unique symbol = RBT.RedBlackTreeTypeId as TypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category constants
+ */
+export const Direction = RBTI.Direction
+
+/**
+ * A Red-Black Tree.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface RedBlackTree<Key, Value> extends Iterable<readonly [Key, Value]>, Equal, Pipeable, Inspectable {
+  readonly [TypeId]: TypeId
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace RedBlackTree {
+  /**
+   * @since 2.0.0
+   */
+  export type Direction = number & {
+    readonly Direction: unique symbol
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isRedBlackTree: {
+  <K, V>(u: Iterable<readonly [K, V]>): u is RedBlackTree<K, V>
+  (u: unknown): u is RedBlackTree<unknown, unknown>
+} = RBT.isRedBlackTree
+
+/**
+ * Creates an empty `RedBlackTree`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: <K, V = never>(ord: Order<K>) => RedBlackTree<K, V> = RBT.empty
+
+/**
+ * Constructs a new tree from an iterable of key-value pairs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: <K, V>(ord: Order<K>) => (entries: Iterable<readonly [K, V]>) => RedBlackTree<K, V> =
+  RBT.fromIterable
+
+/**
+ * Constructs a new `RedBlackTree` from the specified entries.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <K>(
+  ord: Order<K>
+) => <Entries extends Array<readonly [K, any]>>(
+  ...entries: Entries
+) => RedBlackTree<K, Entries[number] extends readonly [any, infer V] ? V : never> = RBT.make
+
+/**
+ * Returns an iterator that points to the element at the specified index of the
+ * tree.
+ *
+ * **Note**: The iterator will run through elements in order.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const at: {
+  (index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, index: number): Iterable<readonly [K, V]>
+} = RBT.atForwards
+
+/**
+ * Returns an iterator that points to the element at the specified index of the
+ * tree.
+ *
+ * **Note**: The iterator will run through elements in reverse order.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const atReversed: {
+  (index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, index: number): Iterable<readonly [K, V]>
+} = RBT.atBackwards
+
+/**
+ * Finds all values in the tree associated with the specified key.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const findAll: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Chunk<V>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Chunk<V>
+} = RBT.findAll
+
+/**
+ * Finds the first value in the tree associated with the specified key, if it exists.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const findFirst: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Option<V>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Option<V>
+} = RBT.findFirst
+
+/**
+ * Returns the first entry in the tree, if it exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const first: <K, V>(self: RedBlackTree<K, V>) => Option<readonly [K, V]> = RBT.first
+
+/**
+ * Returns the element at the specified index within the tree or `None` if the
+ * specified index does not exist.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const getAt: {
+  (index: number): <K, V>(self: RedBlackTree<K, V>) => Option<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, index: number): Option<readonly [K, V]>
+} = RBT.getAt
+
+/**
+ * Gets the `Order<K>` that the `RedBlackTree<K, V>` is using.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const getOrder: <K, V>(self: RedBlackTree<K, V>) => Order<K> = RBT.getOrder
+
+/**
+ * Returns an iterator that traverse entries in order with keys greater than the
+ * specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const greaterThan: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
+} = RBT.greaterThanForwards
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys greater
+ * than the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const greaterThanReversed: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
+} = RBT.greaterThanBackwards
+
+/**
+ * Returns an iterator that traverse entries in order with keys greater than or
+ * equal to the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const greaterThanEqual: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
+} = RBT.greaterThanEqualForwards
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys greater
+ * than or equal to the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const greaterThanEqualReversed: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
+} = RBT.greaterThanEqualBackwards
+
+/**
+ * Finds the item with key, if it exists.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => boolean
+  <K, V>(self: RedBlackTree<K, V>, key: K): boolean
+} = RBT.has
+
+/**
+ * Insert a new item into the tree.
+ *
+ * @since 2.0.0
+ */
+export const insert: {
+  <K, V>(key: K, value: V): (self: RedBlackTree<K, V>) => RedBlackTree<K, V>
+  <K, V>(self: RedBlackTree<K, V>, key: K, value: V): RedBlackTree<K, V>
+} = RBT.insert
+
+/**
+ * Get all the keys present in the tree in order.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const keys: <K, V>(self: RedBlackTree<K, V>) => IterableIterator<K> = RBT.keysForward
+
+/**
+ * Get all the keys present in the tree in reverse order.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const keysReversed: <K, V>(self: RedBlackTree<K, V>) => IterableIterator<K> = RBT.keysBackward
+
+/**
+ * Returns the last entry in the tree, if it exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const last: <K, V>(self: RedBlackTree<K, V>) => Option<readonly [K, V]> = RBT.last
+
+/**
+ * Returns an iterator that traverse entries in order with keys less than the
+ * specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const lessThan: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
+} = RBT.lessThanForwards
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys less
+ * than the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const lessThanReversed: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
+} = RBT.lessThanBackwards
+
+/**
+ * Returns an iterator that traverse entries in order with keys less than or
+ * equal to the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const lessThanEqual: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
+} = RBT.lessThanEqualForwards
+
+/**
+ * Returns an iterator that traverse entries in reverse order with keys less
+ * than or equal to the specified key.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const lessThanEqualReversed: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
+  <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
+} = RBT.lessThanEqualBackwards
+
+/**
+ * Execute the specified function for each node of the tree, in order.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEach: {
+  <K, V>(f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
+  <K, V>(self: RedBlackTree<K, V>, f: (key: K, value: V) => void): void
+} = RBT.forEach
+
+/**
+ * Visit each node of the tree in order with key greater then or equal to max.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEachGreaterThanEqual: {
+  <K, V>(min: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
+  <K, V>(self: RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void): void
+} = RBT.forEachGreaterThanEqual
+
+/**
+ * Visit each node of the tree in order with key lower then max.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEachLessThan: {
+  <K, V>(max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
+  <K, V>(self: RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void): void
+} = RBT.forEachLessThan
+
+/**
+ * Visit each node of the tree in order with key lower than max and greater
+ * than or equal to min.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEachBetween: {
+  <K, V>(
+    options: {
+      readonly min: K
+      readonly max: K
+      readonly body: (key: K, value: V) => void
+    }
+  ): (self: RedBlackTree<K, V>) => void
+  <K, V>(
+    self: RedBlackTree<K, V>,
+    options: {
+      readonly min: K
+      readonly max: K
+      readonly body: (key: K, value: V) => void
+    }
+  ): void
+} = RBT.forEachBetween
+
+/**
+ * Reduce a state over the entries of the tree.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const reduce: {
+  <Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: RedBlackTree<K, V>) => Z
+  <Z, V, K>(self: RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
+} = RBT.reduce
+
+/**
+ * Removes the entry with the specified key, if it exists.
+ *
+ * @since 2.0.0
+ */
+export const removeFirst: {
+  <K>(key: K): <V>(self: RedBlackTree<K, V>) => RedBlackTree<K, V>
+  <K, V>(self: RedBlackTree<K, V>, key: K): RedBlackTree<K, V>
+} = RBT.removeFirst
+
+/**
+ * Traverse the tree in reverse order.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const reversed: <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]> = RBT.reversed
+
+/**
+ * Returns the size of the tree.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size: <K, V>(self: RedBlackTree<K, V>) => number = RBT.size
+
+/**
+ * Get all values present in the tree in order.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const values: <K, V>(self: RedBlackTree<K, V>) => IterableIterator<V> = RBT.valuesForward
+
+/**
+ * Get all values present in the tree in reverse order.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const valuesReversed: <K, V>(self: RedBlackTree<K, V>) => IterableIterator<V> = RBT.valuesBackward

package/src/Ref.ts

@@ -0,0 +1,159 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect"
+import * as internal from "./internal/ref"
+import type * as Option from "./Option"
+import type { Pipeable } from "./Pipeable"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const RefTypeId: unique symbol = internal.RefTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type RefTypeId = typeof RefTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Ref<A> extends Ref.Variance<A>, Pipeable {
+  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B>
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export declare namespace Ref {
+  /**
+   * @since 2.0.0
+   */
+  export interface Variance<A> {
+    readonly [RefTypeId]: {
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <A>(value: A) => Effect.Effect<never, never, Ref<A>> = internal.make
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const get: <A>(self: Ref<A>) => Effect.Effect<never, never, A> = internal.get
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndSet: {
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<never, never, A>
+  <A>(self: Ref<A>, value: A): Effect.Effect<never, never, A>
+} = internal.getAndSet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdate: {
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<never, never, A>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<never, never, A>
+} = internal.getAndUpdate
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdateSome: {
+  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<never, never, A>
+  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
+} = internal.getAndUpdateSome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modify: {
+  <A, B>(f: (a: A) => readonly [B, A]): (self: Ref<A>) => Effect.Effect<never, never, B>
+  <A, B>(self: Ref<A>, f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B>
+} = internal.modify
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modifySome: {
+  <B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): (self: Ref<A>) => Effect.Effect<never, never, B>
+  <A, B>(self: Ref<A>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<never, never, B>
+} = internal.modifySome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const set: {
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<never, never, void>
+  <A>(self: Ref<A>, value: A): Effect.Effect<never, never, void>
+} = internal.set
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const setAndGet: {
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<never, never, A>
+  <A>(self: Ref<A>, value: A): Effect.Effect<never, never, A>
+} = internal.setAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const update: {
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<never, never, void>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<never, never, void>
+} = internal.update
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateAndGet: {
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<never, never, A>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<never, never, A>
+} = internal.updateAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSome: {
+  <A>(f: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<never, never, void>
+  <A>(self: Ref<A>, f: (a: A) => Option.Option<A>): Effect.Effect<never, never, void>
+} = internal.updateSome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSomeAndGet: {
+  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<never, never, A>
+  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
+} = internal.updateSomeAndGet
+
+/**
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeMake: <A>(value: A) => Ref<A> = internal.unsafeMake

package/src/Reloadable.ts

@@ -0,0 +1,136 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Context from "./Context"
+import type * as Effect from "./Effect"
+import * as internal from "./internal/reloadable"
+import type * as Layer from "./Layer"
+import type * as Schedule from "./Schedule"
+import type * as ScopedRef from "./ScopedRef"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ReloadableTypeId: unique symbol = internal.ReloadableTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type ReloadableTypeId = typeof ReloadableTypeId
+
+/**
+ * A `Reloadable` is an implementation of some service that can be dynamically
+ * reloaded, or swapped out for another implementation on-the-fly.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Reloadable<A> extends Reloadable.Variance<A> {
+  /**
+   * @internal
+   */
+  readonly scopedRef: ScopedRef.ScopedRef<A>
+  /**
+   * @internal
+   */
+  reload(): Effect.Effect<never, unknown, void>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Reloadable {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<A> {
+    readonly [ReloadableTypeId]: {
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * Makes a new reloadable service from a layer that describes the construction
+ * of a static service. The service is automatically reloaded according to the
+ * provided schedule.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const auto: <Out extends Context.Tag<any, any>, In, E, R>(
+  tag: Out,
+  options: {
+    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly schedule: Schedule.Schedule<R, unknown, unknown>
+  }
+) => Layer.Layer<In | R, E, Reloadable<Context.Tag.Identifier<Out>>> = internal.auto
+
+/**
+ * Makes a new reloadable service from a layer that describes the construction
+ * of a static service. The service is automatically reloaded according to a
+ * schedule, which is extracted from the input to the layer.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const autoFromConfig: <Out extends Context.Tag<any, any>, In, E, R>(
+  tag: Out,
+  options: {
+    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<R, unknown, unknown>
+  }
+) => Layer.Layer<In | R, E, Reloadable<Context.Tag.Identifier<Out>>> = internal.autoFromConfig
+
+/**
+ * Retrieves the current version of the reloadable service.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const get: <T extends Context.Tag<any, any>>(
+  tag: T
+) => Effect.Effect<Reloadable<Context.Tag.Identifier<T>>, never, Context.Tag.Service<T>> = internal.get
+
+/**
+ * Makes a new reloadable service from a layer that describes the construction
+ * of a static service.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const manual: <Out extends Context.Tag<any, any>, In, E>(
+  tag: Out,
+  options: { readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>> }
+) => Layer.Layer<In, E, Reloadable<Context.Tag.Identifier<Out>>> = internal.manual
+
+/**
+ * Reloads the specified service.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const reload: <T extends Context.Tag<any, any>>(
+  tag: T
+) => Effect.Effect<Reloadable<Context.Tag.Identifier<T>>, unknown, void> = internal.reload
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const tag: <T extends Context.Tag<any, any>>(
+  tag: T
+) => Context.Tag<Reloadable<Context.Tag.Identifier<T>>, Reloadable<Context.Tag.Service<T>>> = internal.reloadableTag
+
+/**
+ * Forks the reload of the service in the background, ignoring any errors.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const reloadFork: <T extends Context.Tag<any, any>>(
+  tag: T
+) => Effect.Effect<Reloadable<Context.Tag.Identifier<T>>, unknown, void> = internal.reloadFork