effect 3.8.2 → 3.8.4

package/src/Micro.ts

@@ -64,11 +64,11 @@ export type runSymbol = typeof runSymbol
  */
 export interface Micro<out A, out E = never, out R = never> extends Effect<A, E, R> {
   readonly [TypeId]: Micro.Variance<A, E, R>
-  readonly [runSymbol]: (env: Env<any>, onExit: (exit: MicroExit<A, E>) => void) => void
+  [runSymbol](env: Env<any>, onExit: (exit: MicroExit<A, E>) => void): void
+  [Symbol.iterator](): MicroIterator<Micro<A, E, R>>
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: MicroUnify<this>
   [Unify.ignoreSymbol]?: MicroUnifyIgnore
-  [Symbol.iterator](): MicroIterator<Micro<A, E, R>>
 }
 
 /**
@@ -144,6 +144,58 @@ export interface MicroIterator<T extends Micro<any, any, any>> {
   next(...args: ReadonlyArray<any>): IteratorResult<YieldWrap<T>, Micro.Success<T>>
 }
 
+/**
+ * @since 3.8.4
+ * @experimental
+ * @category models
+ */
+export interface MicroClass {
+  new<A, E = never, R = never>(): Micro<A, E, R>
+}
+
+// ----------------------------------------------------------------------------
+// Microable
+// ----------------------------------------------------------------------------
+
+const MicroProto = {
+  ...Effectable.EffectPrototype,
+  _op: "Micro",
+  [TypeId]: {
+    _A: identity,
+    _E: identity,
+    _R: identity
+  },
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this)) as any
+  }
+}
+
+const MicroBase: MicroClass = (function() {
+  function Base() {}
+  Base.prototype = MicroProto
+  return Base as any
+})()
+
+/**
+ * @since 3.8.4
+ * @experimental
+ * @category constructors
+ */
+export abstract class Class<out A, out E = never, out R = never> extends MicroBase<A, E, R> {
+  /**
+   * @since 3.8.4
+   * @experimental
+   */
+  abstract asMicro(): Micro<A, E, R>
+  /**
+   * @since 3.8.4
+   * @experimental
+   */
+  [runSymbol](env: Env<any>, onExit: (exit: MicroExit<A, E>) => void): void {
+    this.asMicro()[runSymbol](env, onExit)
+  }
+}
+
 // ----------------------------------------------------------------------------
 // MicroCause
 // ----------------------------------------------------------------------------
@@ -512,31 +564,6 @@ export interface Env<R> extends Pipeable {
   readonly refs: ReadonlyRecord<string, unknown>
 }
 
-/**
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export const EnvRefTypeId: unique symbol = Symbol.for("effect/Micro/EnvRef")
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export type EnvRefTypeId = typeof EnvRefTypeId
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export interface EnvRef<A> {
-  readonly [EnvRefTypeId]: EnvRefTypeId
-  readonly key: string
-  readonly initial: A
-}
-
 const EnvProto = {
   [EnvTypeId]: {
     _R: identity
@@ -818,8 +845,59 @@ export class MicroSchedulerDefault implements MicroScheduler {
 // Env refs
 // ========================================================================
 
-const EnvRefProto = {
-  [EnvRefTypeId]: EnvRefTypeId
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export const EnvRefTypeId: unique symbol = Symbol.for("effect/Micro/EnvRef")
+
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export type EnvRefTypeId = typeof EnvRefTypeId
+
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export interface EnvRef<A> extends Micro<A> {
+  readonly [EnvRefTypeId]: EnvRefTypeId
+  readonly key: string
+  readonly initial: A
+
+  [Unify.typeSymbol]?: unknown
+  [Unify.unifySymbol]?: EnvRefUnify<this>
+  [Unify.ignoreSymbol]?: EnvRefUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.4
+ * @experimental
+ */
+export interface EnvRefUnify<A extends { [Unify.typeSymbol]?: any }> extends MicroUnify<A> {
+  EnvRef?: () => A[Unify.typeSymbol] extends EnvRef<infer A0> | infer _ ? EnvRef<A0> : never
+}
+
+/**
+ * @category models
+ * @since 3.8.4
+ * @experimental
+ */
+export interface EnvRefUnifyIgnore extends MicroUnifyIgnore {
+  Micro?: true
+}
+
+const EnvRefProto: ThisType<EnvRef<any>> = {
+  ...MicroProto,
+  [EnvRefTypeId]: EnvRefTypeId,
+  [runSymbol](env: Env<any>, onExit: (exit: MicroExit<any, any>) => void) {
+    getEnvRef(this)[runSymbol](env, onExit)
+  }
 }
 
 /**
@@ -929,19 +1007,6 @@ export const withConcurrency: {
 // constructors
 // ----------------------------------------------------------------------------
 
-const MicroProto = {
-  ...Effectable.EffectPrototype,
-  _op: "Micro",
-  [TypeId]: {
-    _A: identity,
-    _E: identity,
-    _R: identity
-  },
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this)) as any
-  }
-}
-
 const microDepthState = globalValue("effect/Micro/microDepthState", () => ({
   depth: 0,
   maxDepthBeforeYield: currentMaxDepthBeforeYield.initial
@@ -3652,7 +3717,7 @@ export type HandleTypeId = typeof HandleTypeId
  * @experimental
  * @category handle & forking
  */
-export interface Handle<A, E = never> {
+export interface Handle<A, E = never> extends Micro<A, E> {
   readonly [HandleTypeId]: HandleTypeId
   readonly await: Micro<MicroExit<A, E>>
   readonly join: Micro<A, E>
@@ -3661,6 +3726,28 @@ export interface Handle<A, E = never> {
   readonly addObserver: (observer: (exit: MicroExit<A, E>) => void) => void
   readonly removeObserver: (observer: (exit: MicroExit<A, E>) => void) => void
   readonly unsafePoll: () => MicroExit<A, E> | null
+
+  [Unify.typeSymbol]?: unknown
+  [Unify.unifySymbol]?: HandleUnify<this>
+  [Unify.ignoreSymbol]?: HandleUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.4
+ * @experimental
+ */
+export interface HandleUnify<A extends { [Unify.typeSymbol]?: any }> extends MicroUnify<A> {
+  Handle?: () => A[Unify.typeSymbol] extends Handle<infer A0, infer E0> | infer _ ? Handle<A0, E0> : never
+}
+
+/**
+ * @category models
+ * @since 3.8.4
+ * @experimental
+ */
+export interface HandleUnifyIgnore extends MicroUnifyIgnore {
+  Micro?: true
 }
 
 /**
@@ -3671,7 +3758,7 @@ export interface Handle<A, E = never> {
 export const isHandle = (u: unknown): u is Handle<unknown, unknown> =>
   typeof u === "object" && u !== null && HandleTypeId in u
 
-class HandleImpl<A, E> implements Handle<A, E> {
+class HandleImpl<A, E> extends Class<A, E> implements Handle<A, E> {
   readonly [HandleTypeId]: HandleTypeId
 
   readonly observers: Set<(exit: MicroExit<A, E>) => void> = new Set()
@@ -3680,6 +3767,7 @@ class HandleImpl<A, E> implements Handle<A, E> {
   readonly isRoot: boolean
 
   constructor(readonly parentSignal: AbortSignal, controller?: AbortController) {
+    super()
     this[HandleTypeId] = HandleTypeId
     this.isRoot = controller !== undefined
     this._controller = controller ?? new AbortController()
@@ -3746,6 +3834,10 @@ class HandleImpl<A, E> implements Handle<A, E> {
       return this.await
     })
   }
+
+  asMicro(): Micro<A, E> {
+    return this.join
+  }
 }
 
 /**

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,9 +150,9 @@ 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
@@ -132,8 +164,8 @@ export const extend: {
 } = 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,9 +176,9 @@ 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
@@ -158,9 +190,9 @@ export const use: {
 } = 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/internal/fiberRuntime.ts

@@ -1471,26 +1471,32 @@ export const tracerLogger = globalValue(
       logLevel,
       message
     }) => {
-      const span = Option.flatMap(fiberRefs.get(context, core.currentContext), Context.getOption(tracer.spanTag))
-      const clockService = Option.map(
-        fiberRefs.get(context, defaultServices.currentServices),
-        (_) => Context.get(_, clock.clockTag)
+      const span = Context.getOption(
+        fiberRefs.getOrDefault(context, core.currentContext),
+        tracer.spanTag
       )
-      if (span._tag === "None" || span.value._tag === "ExternalSpan" || clockService._tag === "None") {
+      if (span._tag === "None" || span.value._tag === "ExternalSpan") {
         return
       }
+      const clockService = Context.unsafeGet(
+        fiberRefs.getOrDefault(context, defaultServices.currentServices),
+        clock.clockTag
+      )
 
-      const attributes = Object.fromEntries(HashMap.map(annotations, Inspectable.toStringUnknown))
+      const attributes: Record<string, unknown> = {}
+      for (const [key, value] of annotations) {
+        attributes[key] = value
+      }
       attributes["effect.fiberId"] = FiberId.threadName(fiberId)
       attributes["effect.logLevel"] = logLevel.label
 
       if (cause !== null && cause._tag !== "Empty") {
-        attributes["effect.cause"] = internalCause.pretty(cause)
+        attributes["effect.cause"] = internalCause.pretty(cause, { renderErrorCause: true })
       }
 
       span.value.event(
-        String(message),
-        clockService.value.unsafeCurrentTimeNanos(),
+        Inspectable.toStringUnknown(Array.isArray(message) ? message[0] : message),
+        clockService.unsafeCurrentTimeNanos(),
         attributes
       )
     })

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.8.2"
+let moduleVersion = "3.8.4"
 
 export const getCurrentVersion = () => moduleVersion