effect 2.0.0-next.46 → 2.0.0-next.48

package/src/Effect.ts

@@ -21,23 +21,20 @@ import type * as FiberRef from "./FiberRef"
 import type * as FiberRefs from "./FiberRefs"
 import type * as FiberRefsPatch from "./FiberRefsPatch"
 import type { LazyArg } from "./Function"
-import { identity } from "./Function"
+import { dual, identity } from "./Function"
 import type * as HashMap from "./HashMap"
 import type * as HashSet from "./HashSet"
 import type { TypeLambda } from "./HKT"
-import { clockTag } from "./internal/clock"
 import * as core from "./internal/core"
 import * as effect from "./internal/core-effect"
 import * as defaultServices from "./internal/defaultServices"
 import * as circular from "./internal/effect/circular"
 import * as fiberRuntime from "./internal/fiberRuntime"
 import * as layer from "./internal/layer"
-import * as circularLayer from "./internal/layer/circular"
 import * as query from "./internal/query"
 import * as _runtime from "./internal/runtime"
 import * as _schedule from "./internal/schedule"
 import type * as Layer from "./Layer"
-import type * as Logger from "./Logger"
 import type { LogLevel } from "./LogLevel"
 import type * as Metric from "./Metric"
 import type * as MetricLabel from "./MetricLabel"
@@ -2726,15 +2723,6 @@ export const withConcurrency: {
 // scheduler
 // ---------------------------------------------------------------------------------------
 
-/**
- * @since 2.0.0
- * @category scheduler
- */
-export const setScheduler = (scheduler: Scheduler.Scheduler): Layer.Layer<never, never, never> =>
-  layer.scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(Scheduler.currentScheduler, scheduler)
-  )
-
 /**
  * Sets the provided scheduler for usage in the wrapped effect
  *
@@ -2789,15 +2777,6 @@ export const clock: Effect<never, never, Clock.Clock> = effect.clock
  */
 export const clockWith: <R, E, A>(f: (clock: Clock.Clock) => Effect<R, E, A>) => Effect<R, E, A> = effect.clockWith
 
-/**
- * @since 2.0.0
- * @category clock
- */
-export const setClock = <A extends Clock.Clock>(clock: A): Layer.Layer<never, never, never> =>
-  layer.scopedDiscard(
-    fiberRuntime.fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(clockTag, clock))
-  )
-
 /**
  * Sets the implementation of the clock service to the specified value and
  * restores it to its original value when the scope is closed.
@@ -2988,15 +2967,6 @@ export const config: <A>(config: Config<A>) => Effect<never, ConfigError, A> = d
 export const configProviderWith: <R, E, A>(f: (configProvider: ConfigProvider) => Effect<R, E, A>) => Effect<R, E, A> =
   defaultServices.configProviderWith
 
-/**
- * Sets the current `ConfigProvider`.
- *
- * @since 2.0.0
- * @category config
- */
-export const setConfigProvider: (configProvider: ConfigProvider) => Layer.Layer<never, never, never> =
-  circularLayer.setConfigProvider
-
 /**
  * Executes the specified workflow with the specified configuration provider.
  *
@@ -4265,10 +4235,10 @@ export const withLogSpan: {
  * @category logging
  */
 export const annotateLogs: {
-  (key: string, value: Logger.AnnotationValue): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
-  (values: Record<string, Logger.AnnotationValue>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
-  <R, E, A>(effect: Effect<R, E, A>, key: string, value: Logger.AnnotationValue): Effect<R, E, A>
-  <R, E, A>(effect: Effect<R, E, A>, values: Record<string, Logger.AnnotationValue>): Effect<R, E, A>
+  (key: string, value: unknown): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
+  (values: Record<string, unknown>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A>(effect: Effect<R, E, A>, key: string, value: unknown): Effect<R, E, A>
+  <R, E, A>(effect: Effect<R, E, A>, values: Record<string, unknown>): Effect<R, E, A>
 } = effect.annotateLogs
 
 /**
@@ -4277,8 +4247,7 @@ export const annotateLogs: {
  * @since 2.0.0
  * @category logging
  */
-export const logAnnotations: Effect<never, never, HashMap.HashMap<string, Logger.AnnotationValue>> =
-  effect.logAnnotations
+export const logAnnotations: Effect<never, never, HashMap.HashMap<string, unknown>> = effect.logAnnotations
 
 /**
  * Decides wether child fibers will report or not unhandled errors via the logger
@@ -4291,15 +4260,6 @@ export const withUnhandledErrorLogLevel: {
   <R, E, B>(self: Effect<R, E, B>, level: Option.Option<LogLevel>): Effect<R, E, B>
 } = core.withUnhandledErrorLogLevel
 
-/**
- * @since 2.0.0
- * @category logging
- */
-export const setUnhandledErrorLogLevel = (level: Option.Option<LogLevel>): Layer.Layer<never, never, never> =>
-  layer.scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(core.currentUnhandledErrorLogLevel, level)
-  )
-
 // -------------------------------------------------------------------------------------
 // alternatives
 // -------------------------------------------------------------------------------------
@@ -4744,6 +4704,21 @@ export const zipWith: {
   ): Effect<R | R2, E | E2, B>
 } = fiberRuntime.zipWithOptions
 
+// -------------------------------------------------------------------------------------
+// applicatives
+// -------------------------------------------------------------------------------------
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const ap: {
+  <R2, E2, A>(that: Effect<R2, E2, A>): <R, E, B>(self: Effect<R, E, (a: A) => B>) => Effect<R | R2, E | E2, B>
+  <R, E, A, B, R2, E2>(self: Effect<R, E, (a: A) => B>, that: Effect<R2, E2, A>): Effect<R | R2, E | E2, B>
+} = dual(
+  2,
+  <R, E, A, B, R2, E2>(self: Effect<R, E, (a: A) => B>, that: Effect<R2, E2, A>): Effect<R | R2, E | E2, B> =>
+    zipWith(self, that, (f, a) => f(a))
+)
 // -------------------------------------------------------------------------------------
 // requests & batching
 // -------------------------------------------------------------------------------------
@@ -4812,42 +4787,6 @@ export const withRequestBatching: {
   <R, E, A>(self: Effect<R, E, A>, requestBatching: boolean): Effect<R, E, A>
 } = core.withRequestBatching
 
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export const setRequestBatching = (requestBatching: boolean) =>
-  layer.scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(core.currentRequestBatching, requestBatching)
-  )
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export const setRequestCaching = (requestCaching: boolean) =>
-  layer.scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(query.currentCacheEnabled, requestCaching)
-  )
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export const setRequestCache: {
-  <R, E>(
-    cache: Effect<R, E, Request.Cache>
-  ): Layer.Layer<Exclude<R, Scope.Scope>, E, never>
-  (
-    cache: Request.Cache
-  ): Layer.Layer<never, never, never>
-} = (<R, E>(cache: Request.Cache | Effect<R, E, Request.Cache>) =>
-  layer.scopedDiscard(
-    core.isEffect(cache) ?
-      core.flatMap(cache, (x) => fiberRuntime.fiberRefLocallyScoped(query.currentCache as any, x)) :
-      fiberRuntime.fiberRefLocallyScoped(query.currentCache as any, cache)
-  )) as any
-
 /**
  * @since 2.0.0
  * @category requests & batching
@@ -4870,14 +4809,6 @@ export const withRequestCache: {
 // tracing
 // -------------------------------------------------------------------------------------
 
-/**
- * Create a Layer that sets the current Tracer
- *
- * @since 2.0.0
- * @category tracing
- */
-export const setTracer: (tracer: Tracer.Tracer) => Layer.Layer<never, never, never> = circularLayer.setTracer
-
 /**
  * @since 2.0.0
  * @category tracing
@@ -4916,15 +4847,6 @@ export const withTracerTiming: {
   <R, E, A>(effect: Effect<R, E, A>, enabled: boolean): Effect<R, E, A>
 } = core.withTracerTiming
 
-/**
- * @since 2.0.0
- * @category tracing
- */
-export const setTracerTiming: (enabled: boolean) => Layer.Layer<never, never, never> = (enabled: boolean) =>
-  layer.scopedDiscard(
-    fiberRuntime.fiberRefLocallyScoped(core.currentTracerTimingEnabled, enabled)
-  )
-
 /**
  * Adds an annotation to each span in this effect.
  *
@@ -4932,10 +4854,10 @@ export const setTracerTiming: (enabled: boolean) => Layer.Layer<never, never, ne
  * @category tracing
  */
 export const annotateSpans: {
-  (key: string, value: Tracer.AttributeValue): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
-  (values: Record<string, Tracer.AttributeValue>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
-  <R, E, A>(effect: Effect<R, E, A>, key: string, value: Tracer.AttributeValue): Effect<R, E, A>
-  <R, E, A>(effect: Effect<R, E, A>, values: Record<string, Tracer.AttributeValue>): Effect<R, E, A>
+  (key: string, value: unknown): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
+  (values: Record<string, unknown>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A>(effect: Effect<R, E, A>, key: string, value: unknown): Effect<R, E, A>
+  <R, E, A>(effect: Effect<R, E, A>, values: Record<string, unknown>): Effect<R, E, A>
 } = effect.annotateSpans
 
 /**
@@ -4945,8 +4867,8 @@ export const annotateSpans: {
  * @category tracing
  */
 export const annotateCurrentSpan: {
-  (key: string, value: Tracer.AttributeValue): Effect<never, never, void>
-  (values: Record<string, Tracer.AttributeValue>): Effect<never, never, void>
+  (key: string, value: unknown): Effect<never, never, void>
+  (values: Record<string, unknown>): Effect<never, never, void>
 } = effect.annotateCurrentSpan
 
 /**
@@ -4965,8 +4887,7 @@ export const currentParentSpan: Effect<never, never, Option.Option<Tracer.Parent
  * @since 2.0.0
  * @category tracing
  */
-export const spanAnnotations: Effect<never, never, HashMap.HashMap<string, Tracer.AttributeValue>> =
-  effect.spanAnnotations
+export const spanAnnotations: Effect<never, never, HashMap.HashMap<string, unknown>> = effect.spanAnnotations
 
 /**
  * @since 2.0.0
@@ -4983,12 +4904,12 @@ export const spanLinks: Effect<never, never, Chunk.Chunk<Tracer.SpanLink>> = eff
 export const linkSpans: {
   (
     span: Tracer.ParentSpan,
-    attributes?: Record<string, Tracer.AttributeValue>
+    attributes?: Record<string, unknown>
   ): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
   <R, E, A>(
     self: Effect<R, E, A>,
     span: Tracer.ParentSpan,
-    attributes?: Record<string, Tracer.AttributeValue>
+    attributes?: Record<string, unknown>
   ): Effect<R, E, A>
 } = effect.linkSpans
 
@@ -5001,40 +4922,36 @@ export const linkSpans: {
 export const makeSpan: (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
 ) => Effect<never, never, Tracer.Span> = effect.makeSpan
 
 /**
- * Adds the provided span to the span stack.
- *
- * @since 2.0.0
- * @category tracing
- */
-export const setParentSpan: (span: Tracer.ParentSpan) => Layer.Layer<never, never, never> = circularLayer.setParentSpan
-
-/**
- * Create and add a span to the current span stack.
+ * Create a new span for tracing, and automatically close it when the Scope
+ * finalizes.
  *
- * The span is ended when the Layer is released.
+ * The span is not added to the current span stack, so no child spans will be
+ * created for it.
  *
  * @since 2.0.0
  * @category tracing
  */
-export const setSpan: (
+export const makeSpanScoped: (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
-) => Layer.Layer<never, never, never> = circularLayer.setSpan
+) => Effect<Scope.Scope, never, Tracer.Span> = fiberRuntime.makeSpanScoped
 
 /**
  * Create a new span for tracing, and automatically close it when the effect
@@ -5051,10 +4968,11 @@ export const useSpan: {
   <R, E, A>(
     name: string,
     options: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      readonly attributes?: Record<string, unknown>
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
+      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     },
     evaluate: (span: Tracer.Span) => Effect<R, E, A>
@@ -5062,74 +4980,90 @@ export const useSpan: {
 } = effect.useSpan
 
 /**
- * Create a new span for tracing, and automatically close it when the Scope
- * finalizes.
- *
- * The span is not added to the current span stack, so no child spans will be
- * created for it.
+ * Wraps the effect with a new span for tracing.
  *
  * @since 2.0.0
  * @category tracing
  */
-export const useSpanScoped: (
-  name: string,
-  options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
-    readonly links?: ReadonlyArray<Tracer.SpanLink>
-    readonly parent?: Tracer.ParentSpan
-    readonly root?: boolean
-    readonly context?: Context.Context<never>
-  }
-) => Effect<Scope.Scope, never, Tracer.Span> = fiberRuntime.useSpanScoped
+export const withSpan: {
+  (
+    name: string,
+    options?: {
+      readonly attributes?: Record<string, unknown>
+      readonly links?: ReadonlyArray<Tracer.SpanLink>
+      readonly parent?: Tracer.ParentSpan
+      readonly root?: boolean
+      readonly sampled?: boolean
+      readonly context?: Context.Context<never>
+    }
+  ): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A>(
+    self: Effect<R, E, A>,
+    name: string,
+    options?: {
+      readonly attributes?: Record<string, unknown>
+      readonly links?: ReadonlyArray<Tracer.SpanLink>
+      readonly parent?: Tracer.ParentSpan
+      readonly root?: boolean
+      readonly sampled?: boolean
+      readonly context?: Context.Context<never>
+    }
+  ): Effect<R, E, A>
+} = effect.withSpan
 
 /**
  * Wraps the effect with a new span for tracing.
  *
+ * The span is ended when the Scope is finalized.
+ *
  * @since 2.0.0
  * @category tracing
  */
-export const withSpan: {
+export const withSpanScoped: {
   (
     name: string,
     options?: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      readonly attributes?: Record<string, unknown>
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
+      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
-  ): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
+  ): <R, E, A>(self: Effect<R, E, A>) => Effect<R | Scope.Scope, E, A>
   <R, E, A>(
     self: Effect<R, E, A>,
     name: string,
     options?: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      readonly attributes?: Record<string, unknown>
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
+      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
-  ): Effect<R, E, A>
-} = effect.withSpan
+  ): Effect<Scope.Scope | R, E, A>
+} = fiberRuntime.withSpanScoped
 
 /**
  * Create and add a span to the current span stack.
  *
- * The span is ended when the Scope is finalized.
+ * The span is ended & removed from the stack when the Scope is finalized.
  *
  * @since 2.0.0
  * @category tracing
  */
-export const withSpanScoped: (
+export const setSpan: (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
-) => Effect<Scope.Scope, never, void> = fiberRuntime.withSpanScoped
+) => Effect<Scope.Scope, never, void> = fiberRuntime.setSpan
 
 /**
  * Adds the provided span to the current span stack.
@@ -5148,8 +5082,7 @@ export const withParentSpan: {
  * @since 2.0.0
  * @category tracing
  */
-export const withParentSpanScoped: (span: Tracer.ParentSpan) => Effect<Scope.Scope, never, void> =
-  fiberRuntime.withParentSpanScoped
+export const setParentSpan: (span: Tracer.ParentSpan) => Effect<Scope.Scope, never, void> = fiberRuntime.setParentSpan
 
 // -------------------------------------------------------------------------------------
 // optionality

package/src/Either.ts

@@ -503,6 +503,39 @@ export const flatMap: {
     isLeft(self) ? left(self.left) : f(self.right)
 )
 
+/**
+ * @since 2.0.0
+ * @category combining
+ */
+export const zipWith: {
+  <E2, A2, A, B>(
+    that: Either<E2, A2>,
+    f: (a: A, b: A2) => B
+  ): <E>(self: Either<E, A>) => Either<E2 | E, B>
+  <E, A, E2, A2, B>(
+    self: Either<E, A>,
+    that: Either<E2, A2>,
+    f: (a: A, b: A2) => B
+  ): Either<E | E2, B>
+} = dual(
+  3,
+  <E, A, E2, A2, B>(self: Either<E, A>, that: Either<E2, A2>, f: (a: A, b: A2) => B): Either<E | E2, B> =>
+    flatMap(self, (a) => map(that, (b) => f(a, b)))
+)
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const ap: {
+  <E2, A>(that: Either<E2, A>): <E, B>(self: Either<E, (a: A) => B>) => Either<E | E2, B>
+  <E, A, B, E2>(self: Either<E, (a: A) => B>, that: Either<E2, A>): Either<E | E2, B>
+} = dual(
+  2,
+  <E, A, B, E2>(self: Either<E, (a: A) => B>, that: Either<E2, A>): Either<E | E2, B> =>
+    zipWith(self, that, (f, a) => f(a))
+)
+
 /**
  * Takes a structure of `Option`s and returns an `Option` of values with the same structure.
  *

package/src/FiberRef.ts

@@ -316,8 +316,7 @@ export const unhandledErrorLogLevel: FiberRef<Option.Option<LogLevel.LogLevel>>
  * @since 2.0.0
  * @category fiberRefs
  */
-export const currentLogAnnotations: FiberRef<HashMap.HashMap<string, Logger.AnnotationValue>> =
-  core.currentLogAnnotations
+export const currentLogAnnotations: FiberRef<HashMap.HashMap<string, unknown>> = core.currentLogAnnotations
 
 /**
  * @since 2.0.0
@@ -383,7 +382,7 @@ export const currentTracerTimingEnabled: FiberRef<boolean> = core.currentTracerT
  * @since 2.0.0
  * @category fiberRefs
  */
-export const currentTracerSpanAnnotations: FiberRef<HashMap.HashMap<string, Tracer.AttributeValue>> =
+export const currentTracerSpanAnnotations: FiberRef<HashMap.HashMap<string, unknown>> =
   core.currentTracerSpanAnnotations
 
 /**