effect 3.8.3 → 3.8.5

package/src/ScheduleInterval.ts

@@ -56,7 +56,21 @@ export const empty: Interval = internal.empty
  * @category ordering
  */
 export const lessThan: {
+  /**
+   * Returns `true` if this `Interval` is less than `that` interval, `false`
+   * otherwise.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (that: Interval): (self: Interval) => boolean
+  /**
+   * Returns `true` if this `Interval` is less than `that` interval, `false`
+   * otherwise.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (self: Interval, that: Interval): boolean
 } = internal.lessThan
 
@@ -67,7 +81,19 @@ export const lessThan: {
  * @category ordering
  */
 export const min: {
+  /**
+   * Returns the minimum of two `Interval`s.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (that: Interval): (self: Interval) => Interval
+  /**
+   * Returns the minimum of two `Interval`s.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (self: Interval, that: Interval): Interval
 } = internal.min
 
@@ -78,7 +104,19 @@ export const min: {
  * @category ordering
  */
 export const max: {
+  /**
+   * Returns the maximum of two `Interval`s.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (that: Interval): (self: Interval) => Interval
+  /**
+   * Returns the maximum of two `Interval`s.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (self: Interval, that: Interval): Interval
 } = internal.max
 
@@ -106,7 +144,21 @@ export const isNonEmpty: (self: Interval) => boolean = internal.isNonEmpty
  * @category ordering
  */
 export const intersect: {
+  /**
+   * Computes a new `Interval` which is the intersection of this `Interval` and
+   * that `Interval`.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (that: Interval): (self: Interval) => Interval
+  /**
+   * Computes a new `Interval` which is the intersection of this `Interval` and
+   * that `Interval`.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (self: Interval, that: Interval): Interval
 } = internal.intersect
 
@@ -128,7 +180,23 @@ export const size: (self: Interval) => Duration.Duration = internal.size
  * @category utils
  */
 export const union: {
+  /**
+   * Computes a new `Interval` which is the union of this `Interval` and that
+   * `Interval` as a `Some`, otherwise returns `None` if the two intervals cannot
+   * form a union.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (that: Interval): (self: Interval) => Option.Option<Interval>
+  /**
+   * Computes a new `Interval` which is the union of this `Interval` and that
+   * `Interval` as a `Some`, otherwise returns `None` if the two intervals cannot
+   * form a union.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (self: Interval, that: Interval): Option.Option<Interval>
 } = internal.union
 

package/src/ScheduleIntervals.ts

@@ -59,7 +59,19 @@ export const fromIterable: (intervals: Iterable<Interval.Interval>) => Intervals
  * @category utils
  */
 export const union: {
+  /**
+   * Computes the union of this `Intervals` and  that `Intervals`
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (that: Intervals): (self: Intervals) => Intervals
+  /**
+   * Computes the union of this `Intervals` and  that `Intervals`
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (self: Intervals, that: Intervals): Intervals
 } = internal.union
 
@@ -70,7 +82,19 @@ export const union: {
  * @category utils
  */
 export const intersect: {
+  /**
+   * Produces the intersection of this `Intervals` and that `Intervals`.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (that: Intervals): (self: Intervals) => Intervals
+  /**
+   * Produces the intersection of this `Intervals` and that `Intervals`.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (self: Intervals, that: Intervals): Intervals
 } = internal.intersect
 
@@ -98,7 +122,21 @@ export const end: (self: Intervals) => number = internal.end
  * @category ordering
  */
 export const lessThan: {
+  /**
+   * Returns `true` if the start of this `Intervals` is before the start of that
+   * `Intervals`, `false` otherwise.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (that: Intervals): (self: Intervals) => boolean
+  /**
+   * Returns `true` if the start of this `Intervals` is before the start of that
+   * `Intervals`, `false` otherwise.
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (self: Intervals, that: Intervals): boolean
 } = internal.lessThan
 
@@ -117,6 +155,18 @@ export const isNonEmpty: (self: Intervals) => boolean = internal.isNonEmpty
  * @category ordering
  */
 export const max: {
+  /**
+   * Returns the maximum of the two `Intervals` (i.e. which has the latest start).
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (that: Intervals): (self: Intervals) => Intervals
+  /**
+   * Returns the maximum of the two `Intervals` (i.e. which has the latest start).
+   *
+   * @since 2.0.0
+   * @category ordering
+   */
   (self: Intervals, that: Intervals): Intervals
 } = internal.max

package/src/Scheduler.ts

@@ -348,6 +348,8 @@ export const currentScheduler: FiberRef<Scheduler> = globalValue(
 
 /** @internal */
 export const withScheduler = dual<
+  /** @internal */
   (scheduler: Scheduler) => <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>,
+  /** @internal */
   <A, E, R>(self: Effect<A, E, R>, scheduler: Scheduler) => Effect<A, E, R>
 >(2, (self, scheduler) => core.fiberRefLocally(self, currentScheduler, scheduler))

package/src/Scope.ts

@@ -11,47 +11,67 @@ import * as fiberRuntime from "./internal/fiberRuntime.js"
 import type { Pipeable } from "./Pipeable.js"
 
 /**
+ * A unique identifier for the `Scope` type.
+ *
  * @since 2.0.0
  * @category symbols
  */
 export const ScopeTypeId: unique symbol = core.ScopeTypeId
 
 /**
+ * The type of the unique identifier for `Scope`.
+ *
  * @since 2.0.0
  * @category symbols
  */
 export type ScopeTypeId = typeof ScopeTypeId
 
 /**
+ * A unique identifier for the `CloseableScope` type.
+ *
  * @since 2.0.0
  * @category symbols
  */
 export const CloseableScopeTypeId: unique symbol = core.CloseableScopeTypeId
 
 /**
+ * The type of the unique identifier for `CloseableScope`.
+ *
  * @since 2.0.0
  * @category symbols
  */
 export type CloseableScopeTypeId = typeof CloseableScopeTypeId
 
 /**
+ * Represents a scope that manages finalizers and can fork child scopes.
+ *
  * @since 2.0.0
  * @category models
  */
 export interface Scope extends Pipeable {
   readonly [ScopeTypeId]: ScopeTypeId
+  /**
+   * The execution strategy for running finalizers in this scope.
+   */
   readonly strategy: ExecutionStrategy.ExecutionStrategy
   /**
+   * Forks a new child scope with the specified execution strategy. The child scope
+   * will automatically be closed when this scope is closed.
+   *
    * @internal
    */
   fork(strategy: ExecutionStrategy.ExecutionStrategy): Effect.Effect<Scope.Closeable>
   /**
+   * Adds a finalizer to this scope. The finalizer will be run when the scope is closed.
+   *
    * @internal
    */
   addFinalizer(finalizer: Scope.Finalizer): Effect.Effect<void>
 }
 
 /**
+ * A scope that can be explicitly closed with a specified exit value.
+ *
  * @since 2.0.0
  * @category models
  */
@@ -59,12 +79,16 @@ export interface CloseableScope extends Scope, Pipeable {
   readonly [CloseableScopeTypeId]: CloseableScopeTypeId
 
   /**
+   * Closes this scope with the given exit value, running all finalizers.
+   *
    * @internal
    */
   close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<void>
 }
 
 /**
+ * A tag representing the current `Scope` in the environment.
+ *
  * @since 2.0.0
  * @category context
  */
@@ -75,11 +99,15 @@ export const Scope: Context.Tag<Scope, Scope> = fiberRuntime.scopeTag
  */
 export declare namespace Scope {
   /**
+   * A finalizer function that takes an `Exit` value and returns an `Effect`.
+   *
    * @since 2.0.0
    * @category model
    */
   export type Finalizer = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>
   /**
+   * A closeable scope that can be explicitly closed.
+   *
    * @since 2.0.0
    * @category model
    */
@@ -88,8 +116,10 @@ export declare namespace Scope {
 
 /**
  * Adds a finalizer to this scope. The finalizer is guaranteed to be run when
- * the scope is closed.
+ * the scope is closed. Use this when the finalizer does not need to know the
+ * `Exit` value that the scope is closed with.
  *
+ * @see {@link addFinalizerExit}
  * @since 2.0.0
  * @category utils
  */
@@ -99,9 +129,11 @@ export const addFinalizer: (
 ) => Effect.Effect<void> = core.scopeAddFinalizer
 
 /**
- * A simplified version of `addFinalizerWith` when the `finalizer` does not
- * depend on the `Exit` value that the scope is closed with.
+ * Adds a finalizer to this scope. The finalizer receives the `Exit` value
+ * when the scope is closed, allowing it to perform different actions based
+ * on the exit status.
  *
+ * @see {@link addFinalizer}
  * @since 2.0.0
  * @category utils
  */
@@ -109,7 +141,7 @@ export const addFinalizerExit: (self: Scope, finalizer: Scope.Finalizer) => Effe
   core.scopeAddFinalizerExit
 
 /**
- * Closes a scope with the specified exit value, running all finalizers that
+ * Closes this scope with the specified exit value, running all finalizers that
  * have been added to the scope.
  *
  * @since 2.0.0
@@ -118,22 +150,40 @@ export const addFinalizerExit: (self: Scope, finalizer: Scope.Finalizer) => Effe
 export const close: (self: CloseableScope, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void> = core.scopeClose
 
 /**
- * Extends the scope of an `Effect` workflow that needs a scope into this
- * scope by providing it to the workflow but not closing the scope when the
- * workflow completes execution. This allows extending a scoped value into a
+ * Extends the scope of an `Effect` that requires a scope into this scope.
+ * It provides this scope to the effect but does not close the scope when the
+ * effect completes execution. This allows extending a scoped value into a
  * larger scope.
  *
  * @since 2.0.0
  * @category utils
  */
 export const extend: {
+  /**
+   * Extends the scope of an `Effect` that requires a scope into this scope.
+   * It provides this scope to the effect but does not close the scope when the
+   * effect completes execution. This allows extending a scoped value into a
+   * larger scope.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (scope: Scope): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Scope>>
+  /**
+   * Extends the scope of an `Effect` that requires a scope into this scope.
+   * It provides this scope to the effect but does not close the scope when the
+   * effect completes execution. This allows extending a scoped value into a
+   * larger scope.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A, E, R>(effect: Effect.Effect<A, E, R>, scope: Scope): Effect.Effect<A, E, Exclude<R, Scope>>
 } = fiberRuntime.scopeExtend
 
 /**
- * Forks a new scope that is a child of this scope. The child scope will
- * automatically be closed when this scope is closed.
+ * Forks a new child scope with the specified execution strategy. The child scope
+ * will automatically be closed when this scope is closed.
  *
  * @since 2.0.0
  * @category utils
@@ -144,23 +194,41 @@ export const fork: (
 ) => Effect.Effect<CloseableScope> = core.scopeFork
 
 /**
- * Uses the scope by providing it to an `Effect` workflow that needs a scope,
- * guaranteeing that the scope is closed with the result of that workflow as
- * soon as the workflow completes execution, whether by success, failure, or
+ * Provides this closeable scope to an `Effect` that requires a scope,
+ * guaranteeing that the scope is closed with the result of that effect as
+ * soon as the effect completes execution, whether by success, failure, or
  * interruption.
  *
  * @since 2.0.0
  * @category destructors
  */
 export const use: {
+  /**
+   * Provides this closeable scope to an `Effect` that requires a scope,
+   * guaranteeing that the scope is closed with the result of that effect as
+   * soon as the effect completes execution, whether by success, failure, or
+   * interruption.
+   *
+   * @since 2.0.0
+   * @category destructors
+   */
   (scope: CloseableScope): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Scope>>
+  /**
+   * Provides this closeable scope to an `Effect` that requires a scope,
+   * guaranteeing that the scope is closed with the result of that effect as
+   * soon as the effect completes execution, whether by success, failure, or
+   * interruption.
+   *
+   * @since 2.0.0
+   * @category destructors
+   */
   <A, E, R>(effect: Effect.Effect<A, E, R>, scope: CloseableScope): Effect.Effect<A, E, Exclude<R, Scope>>
 } = fiberRuntime.scopeUse
 
 /**
- * Creates a Scope where Finalizers will run according to the `ExecutionStrategy`.
- *
- * If an ExecutionStrategy is not provided `sequential` will be used.
+ * Creates a new closeable scope where finalizers will run according to the
+ * specified `ExecutionStrategy`. If no execution strategy is provided, `sequential`
+ * will be used by default.
  *
  * @since 2.0.0
  * @category constructors

package/src/ScopedRef.ts

@@ -91,6 +91,28 @@ export const make: <A>(evaluate: LazyArg<A>) => Effect.Effect<ScopedRef<A>, neve
  * @category getters
  */
 export const set: {
+  /**
+   * Sets the value of this reference to the specified resourcefully-created
+   * value. Any resources associated with the old value will be released.
+   *
+   * This method will not return until either the reference is successfully
+   * changed to the new value, with old resources released, or until the attempt
+   * to acquire a new value fails.
+   *
+   * @since 2.0.0
+   * @category getters
+   */
   <A, R, E>(acquire: Effect.Effect<A, E, R>): (self: ScopedRef<A>) => Effect.Effect<void, E, Exclude<R, Scope.Scope>>
+  /**
+   * Sets the value of this reference to the specified resourcefully-created
+   * value. Any resources associated with the old value will be released.
+   *
+   * This method will not return until either the reference is successfully
+   * changed to the new value, with old resources released, or until the attempt
+   * to acquire a new value fails.
+   *
+   * @since 2.0.0
+   * @category getters
+   */
   <A, R, E>(self: ScopedRef<A>, acquire: Effect.Effect<A, E, R>): Effect.Effect<void, E, Exclude<R, Scope.Scope>>
 } = internal.set