effect 2.0.0-next.49 → 2.0.0-next.50

package/internal/tracer.esm.js

@@ -16,19 +16,22 @@ const make = options => ({
 
 /** @internal */
 const tracerTag = /*#__PURE__*/Tag( /*#__PURE__*/Symbol.for("effect/Tracer"));
+
+/** @internal */
+const spanTag = /*#__PURE__*/Tag( /*#__PURE__*/Symbol.for("effect/ParentSpan"));
 const ids = /*#__PURE__*/globalValue("effect/Tracer/SpanId.ids", () => make$1(0));
 
 /** @internal */
 class NativeSpan {
   _tag = "Span";
   traceId = "native";
+  sampled = true;
   events = [];
-  constructor(name, parent, context, links, sampled, startTime) {
+  constructor(name, parent, context, links, startTime) {
     this.name = name;
     this.parent = parent;
     this.context = context;
     this.links = links;
-    this.sampled = sampled;
     this.startTime = startTime;
     this.status = {
       _tag: "Started",
@@ -55,7 +58,7 @@ class NativeSpan {
 
 /** @internal */
 const nativeTracer = /*#__PURE__*/make({
-  span: (name, parent, context, links, sampled, startTime) => new NativeSpan(name, parent, context, links, sampled, startTime),
+  span: (name, parent, context, links, startTime) => new NativeSpan(name, parent, context, links, startTime),
   context: f => f()
 });
 
@@ -68,4 +71,4 @@ const externalSpan = options => ({
   context: options.context ?? empty()
 });
 
-export { NativeSpan, TracerTypeId, externalSpan, make, nativeTracer, tracerTag };
+export { NativeSpan, TracerTypeId, externalSpan, make, nativeTracer, spanTag, tracerTag };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.0.0-next.49",
+  "version": "2.0.0-next.50",
   "packageManager": "pnpm@8.7.3",
   "publishConfig": {
     "access": "public"

package/src/BigInt.ts

@@ -13,6 +13,10 @@ import * as order from "./Order"
 import type { Ordering } from "./Ordering"
 import * as predicate from "./Predicate"
 
+const bigint0 = BigInt(0)
+const bigint1 = BigInt(1)
+const bigint2 = BigInt(2)
+
 /**
  * Tests if a value is a `bigint`.
  *
@@ -92,20 +96,50 @@ export const subtract: {
  * If the dividend is not a multiple of the divisor the result will be a `bigint` value
  * which represents the integer division rounded down to the nearest integer.
  *
+ * Returns `None` if the divisor is `0n`.
+ *
  * @param self - The dividend operand.
  * @param that - The divisor operand.
  *
  * @example
  * import { divide } from 'effect/BigInt'
+ * import { some, none } from 'effect/Option'
  *
- * assert.deepStrictEqual(divide(6n, 3n), 2n)
- * assert.deepStrictEqual(divide(6n, 4n), 1n)
+ * assert.deepStrictEqual(divide(6n, 3n), some(2n))
+ * assert.deepStrictEqual(divide(6n, 0n), none())
  *
  * @category math
  * @since 2.0.0
- * @since 2.0.0
  */
 export const divide: {
+  (that: bigint): (self: bigint) => Option.Option<bigint>
+  (self: bigint, that: bigint): Option.Option<bigint>
+} = dual(
+  2,
+  (self: bigint, that: bigint): Option.Option<bigint> => that === bigint0 ? Option.none() : Option.some(self / that)
+)
+
+/**
+ * Provides a division operation on `bigint`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * Throws a `RangeError` if the divisor is `0n`.
+ *
+ * @param self - The dividend operand.
+ * @param that - The divisor operand.
+ *
+ * @example
+ * import { unsafeDivide } from 'effect/BigInt'
+ *
+ * assert.deepStrictEqual(unsafeDivide(6n, 3n), 2n)
+ * assert.deepStrictEqual(unsafeDivide(6n, 4n), 1n)
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const unsafeDivide: {
   (that: bigint): (self: bigint) => bigint
   (self: bigint, that: bigint): bigint
 } = dual(2, (self: bigint, that: bigint): bigint => self / that)
@@ -123,7 +157,7 @@ export const divide: {
  * @category math
  * @since 2.0.0
  */
-export const increment = (n: bigint): bigint => n + 1n
+export const increment = (n: bigint): bigint => n + bigint1
 
 /**
  * Decrements a number by `1n`.
@@ -138,7 +172,7 @@ export const increment = (n: bigint): bigint => n + 1n
  * @category math
  * @since 2.0.0
  */
-export const decrement = (n: bigint): bigint => n - 1n
+export const decrement = (n: bigint): bigint => n - bigint1
 
 /**
  * @category instances
@@ -334,7 +368,7 @@ export const max: {
  * @category math
  * @since 2.0.0
  */
-export const sign = (n: bigint): Ordering => Order(n, 0n)
+export const sign = (n: bigint): Ordering => Order(n, bigint0)
 
 /**
  * Determines the absolute value of a given `bigint`.
@@ -351,7 +385,7 @@ export const sign = (n: bigint): Ordering => Order(n, 0n)
  * @category math
  * @since 2.0.0
  */
-export const abs = (n: bigint): bigint => (n < 0n ? -n : n)
+export const abs = (n: bigint): bigint => (n < bigint0 ? -n : n)
 
 /**
  * Determines the greatest common divisor of two `bigint`s.
@@ -373,7 +407,7 @@ export const gcd: {
   (that: bigint): (self: bigint) => bigint
   (self: bigint, that: bigint): bigint
 } = dual(2, (self: bigint, that: bigint): bigint => {
-  while (that !== 0n) {
+  while (that !== bigint0) {
     const t = that
     that = self % that
     self = t
@@ -418,15 +452,15 @@ export const lcm: {
  * @since 2.0.0
  */
 export const unsafeSqrt = (n: bigint): bigint => {
-  if (n < 0n) {
+  if (n < bigint0) {
     throw new RangeError("Cannot take the square root of a negative number")
   }
-  if (n < 2n) {
+  if (n < bigint2) {
     return n
   }
-  let x = n / 2n
+  let x = n / bigint2
   while (x * x > n) {
-    x = ((n / x) + x) / 2n
+    x = ((n / x) + x) / bigint2
   }
   return x
 }
@@ -449,7 +483,7 @@ export const unsafeSqrt = (n: bigint): bigint => {
  * @since 2.0.0
  */
 export const sqrt = (n: bigint): Option.Option<bigint> =>
-  greaterThanOrEqualTo(n, 0n) ? Option.some(unsafeSqrt(n)) : Option.none<bigint>()
+  greaterThanOrEqualTo(n, bigint0) ? Option.some(unsafeSqrt(n)) : Option.none<bigint>()
 
 /**
  * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint
@@ -465,7 +499,7 @@ export const sqrt = (n: bigint): Option.Option<bigint> =>
  * @since 2.0.0
  */
 export const sumAll = (collection: Iterable<bigint>): bigint => {
-  let out = 0n
+  let out = bigint0
   for (const n of collection) {
     out += n
   }
@@ -486,10 +520,10 @@ export const sumAll = (collection: Iterable<bigint>): bigint => {
  * @since 2.0.0
  */
 export const multiplyAll = (collection: Iterable<bigint>): bigint => {
-  let out = 1n
+  let out = bigint1
   for (const n of collection) {
-    if (n === 0n) {
-      return 0n
+    if (n === bigint0) {
+      return bigint0
     }
     out *= n
   }

package/src/Channel.ts

@@ -2074,7 +2074,6 @@ export const withSpan: {
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
   ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
@@ -2088,7 +2087,6 @@ export const withSpan: {
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
   ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>

package/src/Effect.ts

@@ -7,7 +7,7 @@ import type * as Clock from "./Clock"
 import type { Config } from "./Config"
 import type { ConfigError } from "./ConfigError"
 import type { ConfigProvider } from "./ConfigProvider"
-import * as Context from "./Context"
+import type * as Context from "./Context"
 import type * as Deferred from "./Deferred"
 import type * as Duration from "./Duration"
 import type * as Either from "./Either"
@@ -3145,8 +3145,8 @@ export const serviceMembers: <I, S>(tag: Context.Tag<I, S>) => {
  * @since 2.0.0
  * @category context
  */
-export const serviceOption: <I, A>(tag: Context.Tag<I, A>) => Effect<never, never, Option.Option<A>> = (tag) =>
-  contextWith((_: Context.Context<never>) => Context.getOption(_, tag))
+export const serviceOption: <I, A>(tag: Context.Tag<I, A>) => Effect<never, never, Option.Option<A>> =
+  effect.serviceOption
 
 /**
  * Updates the service with the required service entry.
@@ -4926,7 +4926,6 @@ export const makeSpan: (
     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
@@ -4948,7 +4947,6 @@ export const makeSpanScoped: (
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
 ) => Effect<Scope.Scope, never, Tracer.Span> = fiberRuntime.makeSpanScoped
@@ -4972,7 +4970,6 @@ export const useSpan: {
       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>
@@ -4993,10 +4990,9 @@ export const withSpan: {
       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<Exclude<R, Tracer.ParentSpan>, E, A>
   <R, E, A>(
     self: Effect<R, E, A>,
     name: string,
@@ -5005,10 +5001,9 @@ export const withSpan: {
       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<Exclude<R, Tracer.ParentSpan>, E, A>
 } = effect.withSpan
 
 /**
@@ -5027,10 +5022,9 @@ export const withSpanScoped: {
       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 | Scope.Scope, E, A>
+  ): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, Tracer.ParentSpan> | Scope.Scope, E, A>
   <R, E, A>(
     self: Effect<R, E, A>,
     name: string,
@@ -5039,32 +5033,11 @@ export const withSpanScoped: {
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
-  ): Effect<Scope.Scope | R, E, A>
+  ): Effect<Scope.Scope | Exclude<R, Tracer.ParentSpan>, E, A>
 } = fiberRuntime.withSpanScoped
 
-/**
- * Create and add a span to the current span stack.
- *
- * The span is ended & removed from the stack when the Scope is finalized.
- *
- * @since 2.0.0
- * @category tracing
- */
-export const setSpan: (
-  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<Scope.Scope, never, void> = fiberRuntime.setSpan
-
 /**
  * Adds the provided span to the current span stack.
  *
@@ -5072,18 +5045,10 @@ export const setSpan: (
  * @category tracing
  */
 export const withParentSpan: {
-  (span: Tracer.ParentSpan): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
-  <R, E, A>(self: Effect<R, E, A>, span: Tracer.ParentSpan): Effect<R, E, A>
+  (span: Tracer.ParentSpan): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, Tracer.ParentSpan>, E, A>
+  <R, E, A>(self: Effect<R, E, A>, span: Tracer.ParentSpan): Effect<Exclude<R, Tracer.ParentSpan>, E, A>
 } = effect.withParentSpan
 
-/**
- * Adds the provided span to the current span stack.
- *
- * @since 2.0.0
- * @category tracing
- */
-export const setParentSpan: (span: Tracer.ParentSpan) => Effect<Scope.Scope, never, void> = fiberRuntime.setParentSpan
-
 // -------------------------------------------------------------------------------------
 // optionality
 // -------------------------------------------------------------------------------------

package/src/Either.ts

@@ -606,7 +606,7 @@ export const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>> = (f)
   const iterator = f(adapter)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {
-    return right(void 0) as any
+    return right(state.value) as any
   } else {
     let current = state.value.value
     if (isLeft(current)) {

package/src/FiberRef.ts

@@ -366,12 +366,6 @@ export const currentSupervisor: FiberRef<Supervisor.Supervisor<any>> = fiberRunt
  */
 export const currentMetricLabels: FiberRef<HashSet.HashSet<MetricLabel.MetricLabel>> = core.currentMetricLabels
 
-/**
- * @since 2.0.0
- * @category fiberRefs
- */
-export const currentTracerSpan: FiberRef<List.List<Tracer.ParentSpan>> = core.currentTracerSpan
-
 /**
  * @since 2.0.0
  * @category fiberRefs

package/src/HashMap.ts

@@ -354,7 +354,7 @@ export const forEach: {
  */
 export const reduce: {
   <Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap<K, V>) => Z
-  <Z, V, K>(self: HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
+  <K, V, Z>(self: HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
 } = HM.reduce
 
 /**

package/src/Layer.ts

@@ -876,7 +876,7 @@ export const setConfigProvider: (configProvider: ConfigProvider) => Layer<never,
  * @since 2.0.0
  * @category tracing
  */
-export const setParentSpan: (span: Tracer.ParentSpan) => Layer<never, never, never> = circularLayer.setParentSpan
+export const parentSpan: (span: Tracer.ParentSpan) => Layer<never, never, Tracer.ParentSpan> = circularLayer.parentSpan
 
 /**
  * @since 2.0.0
@@ -937,18 +937,17 @@ export const setScheduler: (scheduler: Scheduler.Scheduler) => Layer<never, neve
  * @since 2.0.0
  * @category tracing
  */
-export const setSpan: (
+export const span: (
   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>
     readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
   }
-) => Layer<never, never, never> = circularLayer.setSpan
+) => Layer<never, never, Tracer.ParentSpan> = circularLayer.span
 
 /**
  * Create a Layer that sets the current Tracer
@@ -990,11 +989,10 @@ export const withSpan: {
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
       readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
     }
-  ): <R, E, A>(self: Layer<R, E, A>) => Layer<R, E, A>
+  ): <R, E, A>(self: Layer<R, E, A>) => Layer<Exclude<R, Tracer.ParentSpan>, E, A>
   <R, E, A>(
     self: Layer<R, E, A>,
     name: string,
@@ -1003,11 +1001,10 @@ export const withSpan: {
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
       readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
     }
-  ): Layer<R, E, A>
+  ): Layer<Exclude<R, Tracer.ParentSpan>, E, A>
 } = internal.withSpan
 
 /**
@@ -1015,6 +1012,6 @@ export const withSpan: {
  * @category tracing
  */
 export const withParentSpan: {
-  (span: Tracer.ParentSpan): <R, E, A>(self: Layer<R, E, A>) => Layer<R, E, A>
-  <R, E, A>(self: Layer<R, E, A>, span: Tracer.ParentSpan): Layer<R, E, A>
+  (span: Tracer.ParentSpan): <R, E, A>(self: Layer<R, E, A>) => Layer<Exclude<R, Tracer.ParentSpan>, E, A>
+  <R, E, A>(self: Layer<R, E, A>, span: Tracer.ParentSpan): Layer<Exclude<R, Tracer.ParentSpan>, E, A>
 } = internal.withParentSpan

package/src/Number.ts

@@ -7,6 +7,8 @@
  */
 import * as equivalence from "./Equivalence"
 import { dual } from "./Function"
+import * as option from "./internal/Option"
+import type { Option } from "./Option"
 import * as order from "./Order"
 import type { Ordering } from "./Ordering"
 import * as predicate from "./Predicate"
@@ -92,13 +94,39 @@ export const subtract: {
  *
  * @example
  * import { divide } from 'effect/Number'
+ * import { some, none } from 'effect/Option'
  *
- * assert.deepStrictEqual(divide(6, 3), 2)
+ * assert.deepStrictEqual(divide(6, 3), some(2))
+ * assert.deepStrictEqual(divide(6, 0), none())
  *
  * @category math
  * @since 2.0.0
  */
 export const divide: {
+  (that: number): (self: number) => Option<number>
+  (self: number, that: number): Option<number>
+} = dual(
+  2,
+  (self: number, that: number): Option<number> => that === 0 ? option.none : option.some(self / that)
+)
+
+/**
+ * Provides a division operation on `number`s.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * @param self - The dividend operand.
+ * @param that - The divisor operand.
+ *
+ * @example
+ * import { unsafeDivide } from 'effect/Number'
+ *
+ * assert.deepStrictEqual(unsafeDivide(6, 3), 2)
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const unsafeDivide: {
   (that: number): (self: number) => number
   (self: number, that: number): number
 } = dual(2, (self: number, that: number): number => self / that)

package/src/Option.ts

@@ -11,7 +11,6 @@ import type { TypeLambda } from "./HKT"
 import type { Inspectable } from "./Inspectable"
 import * as either from "./internal/Either"
 import * as option from "./internal/Option"
-import * as N from "./Number"
 import type { Order } from "./Order"
 import * as order from "./Order"
 import type { Pipeable } from "./Pipeable"
@@ -1117,98 +1116,6 @@ export const exists: {
   <A>(self: Option<A>, predicate: Predicate<A>): boolean => isNone(self) ? false : predicate(self.value)
 )
 
-// -------------------------------------------------------------------------------------
-// math
-// -------------------------------------------------------------------------------------
-
-/**
- * @category math
- * @since 2.0.0
- */
-export const sum: {
-  (self: Option<number>, that: Option<number>): Option<number>
-  (that: Option<number>): (self: Option<number>) => Option<number>
-} = lift2(N.sum)
-
-/**
- * @category math
- * @since 2.0.0
- */
-export const multiply: {
-  (self: Option<number>, that: Option<number>): Option<number>
-  (that: Option<number>): (self: Option<number>) => Option<number>
-} = lift2(N.multiply)
-
-/**
- * @category math
- * @since 2.0.0
- */
-export const subtract: {
-  (self: Option<number>, that: Option<number>): Option<number>
-  (that: Option<number>): (self: Option<number>) => Option<number>
-} = lift2(N.subtract)
-
-/**
- * @category math
- * @since 2.0.0
- */
-export const divide: {
-  (self: Option<number>, that: Option<number>): Option<number>
-  (that: Option<number>): (self: Option<number>) => Option<number>
-} = lift2(N.divide)
-
-/**
- * Sum all numbers in an iterable of `Option<number>` ignoring the `None` values.
- *
- * @param self - The iterable of `Option<number>` to be summed.
- *
- * @example
- * import { sumCompact, some, none } from 'effect/Option'
- *
- * const iterable = [some(2), none(), some(3), none()]
- * assert.deepStrictEqual(sumCompact(iterable), 5)
- *
- * @category math
- * @since 2.0.0
- */
-export const sumCompact = (self: Iterable<Option<number>>): number => {
-  let out = 0
-  for (const oa of self) {
-    if (isSome(oa)) {
-      out += oa.value
-    }
-  }
-  return out
-}
-
-/**
- * Multiply all numbers in an iterable of `Option<number>` ignoring the `None` values.
- *
- * @param self - The iterable of `Option<number>` to be multiplied.
- *
- * @example
- * import { multiplyCompact, some, none } from 'effect/Option'
- *
- * const iterable = [some(2), none(), some(3), none()]
- * assert.deepStrictEqual(multiplyCompact(iterable), 6)
- *
- * @category math
- * @since 2.0.0
- */
-export const multiplyCompact = (self: Iterable<Option<number>>): number => {
-  let out = 1
-  for (const oa of self) {
-    if (isSome(oa)) {
-      const a: number = oa.value
-      if (a === 0) {
-        return 0
-      }
-      out *= a
-    }
-  }
-  return out
-}
-
 // -------------------------------------------------------------------------------------
 // do notation
 // -------------------------------------------------------------------------------------
@@ -1287,7 +1194,7 @@ export const gen: Gen.Gen<OptionTypeLambda, Gen.Adapter<OptionTypeLambda>> = (f)
   const iterator = f(adapter)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {
-    return some(void 0)
+    return some(state.value)
   } else {
     let current = state.value.value
     if (isNone(current)) {