effect 2.0.0-next.60 → 2.0.0-next.62

package/src/internal/core-effect.ts

@@ -827,17 +827,14 @@ export const fiberRefs: Effect.Effect<never, never, FiberRefs.FiberRefs> = core.
 /* @internal */
 export const head = <R, E, A>(
   self: Effect.Effect<R, E, Iterable<A>>
-): Effect.Effect<R, Option.Option<E>, A> =>
-  core.matchEffect(self, {
-    onFailure: (e) => core.fail(Option.some(e)),
-    onSuccess: (as) => {
-      const iterator = as[Symbol.iterator]()
-      const next = iterator.next()
-      if (next.done) {
-        return core.fail(Option.none())
-      }
-      return core.succeed(next.value)
+): Effect.Effect<R, E | Cause.NoSuchElementException, A> =>
+  core.flatMap(self, (as) => {
+    const iterator = as[Symbol.iterator]()
+    const next = iterator.next()
+    if (next.done) {
+      return core.fail(new core.NoSuchElementException())
     }
+    return core.succeed(next.value)
   })
 
 /* @internal */
@@ -1109,17 +1106,14 @@ export const negate = <R, E>(self: Effect.Effect<R, E, boolean>): Effect.Effect<
 /* @internal */
 export const none = <R, E, A>(
   self: Effect.Effect<R, E, Option.Option<A>>
-): Effect.Effect<R, Option.Option<E>, void> =>
-  core.matchEffect(self, {
-    onFailure: (e) => core.fail(Option.some(e)),
-    onSuccess: (option) => {
-      switch (option._tag) {
-        case "None": {
-          return core.unit
-        }
-        case "Some": {
-          return core.fail(Option.none())
-        }
+): Effect.Effect<R, E | Cause.NoSuchElementException, void> =>
+  core.flatMap(self, (option) => {
+    switch (option._tag) {
+      case "None": {
+        return core.unit
+      }
+      case "Some": {
+        return core.fail(new core.NoSuchElementException())
       }
     }
   })
@@ -1899,6 +1893,10 @@ export const serviceMembers = <I, S>(tag: Context.Tag<I, S>): {
 /** @internal */
 export const serviceOption = <I, S>(tag: Context.Tag<I, S>) => core.map(core.context<never>(), Context.getOption(tag))
 
+/** @internal */
+export const serviceOptional = <I, S>(tag: Context.Tag<I, S>) =>
+  core.flatMap(core.context<never>(), Context.getOption(tag))
+
 // -----------------------------------------------------------------------------
 // tracing
 // -----------------------------------------------------------------------------
@@ -1909,21 +1907,19 @@ export const annotateCurrentSpan: {
   (values: Record<string, unknown>): Effect.Effect<never, never, void>
 } = function(): Effect.Effect<never, never, void> {
   const args = arguments
-  return core.flatMap(
+  return ignore(core.flatMap(
     currentSpan,
     (span) =>
-      span._tag === "Some"
-        ? core.sync(() => {
-          if (typeof args[0] === "string") {
-            span.value.attribute(args[0], args[1])
-          } else {
-            for (const key in args[0]) {
-              span.value.attribute(key, args[0][key])
-            }
+      core.sync(() => {
+        if (typeof args[0] === "string") {
+          span.attribute(args[0], args[1])
+        } else {
+          for (const key in args[0]) {
+            span.attribute(key, args[0][key])
           }
-        })
-        : core.unit
-  )
+        }
+      })
+  ))
 }
 
 /* @internal */
@@ -1957,16 +1953,18 @@ export const annotateSpans = dual<
 )
 
 /** @internal */
-export const currentParentSpan: Effect.Effect<never, never, Option.Option<Tracer.ParentSpan>> = serviceOption(
+export const currentParentSpan: Effect.Effect<never, Cause.NoSuchElementException, Tracer.ParentSpan> = serviceOptional(
   internalTracer.spanTag
 )
 
 /** @internal */
-export const currentSpan: Effect.Effect<never, never, Option.Option<Tracer.Span>> = core.map(
+export const currentSpan: Effect.Effect<never, Cause.NoSuchElementException, Tracer.Span> = core.flatMap(
   core.context<never>(),
   (context) => {
     const span = context.unsafeMap.get(internalTracer.spanTag) as Tracer.ParentSpan | undefined
-    return span !== undefined && span._tag === "Span" ? Option.some(span) : Option.none()
+    return span !== undefined && span._tag === "Span"
+      ? core.succeed(span)
+      : core.fail(new core.NoSuchElementException())
   }
 )
 
@@ -2015,43 +2013,47 @@ export const makeSpan = (
     readonly context?: Context.Context<never> | undefined
   }
 ) =>
-  tracerWith((tracer) =>
-    core.flatMap(
-      options?.parent
-        ? succeedSome(options.parent)
+  core.flatMap(fiberRefs, (fiberRefs) =>
+    core.sync(() => {
+      const context = FiberRefs.getOrDefault(fiberRefs, core.currentContext)
+      const services = FiberRefs.getOrDefault(fiberRefs, defaultServices.currentServices)
+
+      const tracer = Context.get(services, internalTracer.tracerTag)
+      const clock = Context.get(services, Clock.Clock)
+      const timingEnabled = FiberRefs.getOrDefault(fiberRefs, core.currentTracerTimingEnabled)
+      const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
+      const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
+
+      const parent = options?.parent
+        ? Option.some(options.parent)
         : options?.root
-        ? succeedNone
-        : currentParentSpan,
-      (parent) =>
-        core.flatMap(
-          core.fiberRefGet(core.currentTracerSpanAnnotations),
-          (annotations) =>
-            core.flatMap(
-              core.fiberRefGet(core.currentTracerSpanLinks),
-              (links) =>
-                core.flatMap(
-                  currentTimeNanosTracing,
-                  (startTime) =>
-                    core.sync(() => {
-                      const linksArray = options?.links
-                        ? [...Chunk.toReadonlyArray(links), ...options.links]
-                        : Chunk.toReadonlyArray(links)
-                      const span = tracer.span(
-                        name,
-                        parent,
-                        options?.context ?? Context.empty(),
-                        linksArray,
-                        startTime
-                      )
-                      HashMap.forEach(annotations, (value, key) => span.attribute(key, value))
-                      Object.entries(options?.attributes ?? {}).forEach(([k, v]) => span.attribute(k, v))
-                      return span
-                    })
-                )
-            )
-        )
-    )
-  )
+        ? Option.none()
+        : Context.getOption(context, internalTracer.spanTag)
+
+      const links = linksFromEnv._tag === "Some" ?
+        [
+          ...Chunk.toReadonlyArray(linksFromEnv.value),
+          ...(options?.links ?? [])
+        ] :
+        options?.links ?? []
+
+      const span = tracer.span(
+        name,
+        parent,
+        options?.context ?? Context.empty(),
+        links,
+        timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0
+      )
+
+      if (annotationsFromEnv._tag === "Some") {
+        HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
+      }
+      if (options?.attributes) {
+        Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
+      }
+
+      return span
+    }))
 
 /* @internal */
 export const spanAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, unknown>> = core

package/src/internal/effect/circular.ts

@@ -399,12 +399,14 @@ export const supervised = dual<
 export const timeout = dual<
   (
     duration: Duration.DurationInput
-  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, Option.Option<A>>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, duration: Duration.DurationInput) => Effect.Effect<R, E, Option.Option<A>>
+  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E | Cause.NoSuchElementException, A>,
+  <R, E, A>(
+    self: Effect.Effect<R, E, A>,
+    duration: Duration.DurationInput
+  ) => Effect.Effect<R, E | Cause.NoSuchElementException, A>
 >(2, (self, duration) =>
-  timeoutTo(self, {
-    onTimeout: Option.none,
-    onSuccess: Option.some,
+  timeoutFail(self, {
+    onTimeout: () => new core.NoSuchElementException(),
     duration
   }))
 

package/src/internal/fiberRuntime.ts

@@ -80,9 +80,9 @@ export const fiberLifetimes = metric.tagged(
   metric.histogram(
     "effect_fiber_lifetimes",
     metricBoundaries.exponential({
-      start: 1.0,
-      factor: 1.3,
-      count: 100
+      start: 0.5,
+      factor: 2,
+      count: 35
     })
   ),
   "time_unit",
@@ -2225,7 +2225,7 @@ export const mergeAll = dual<
     readonly batching?: boolean | "inherit" | undefined
   }) => Effect.Effect<R, E, Z>
 >(
-  (args) => Predicate.isIterable(args[0]),
+  (args) => Predicate.isFunction(args[2]),
   <R, E, A, Z>(elements: Iterable<Effect.Effect<R, E, A>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined

package/src/internal/layer.ts

@@ -912,6 +912,9 @@ export const succeedContext = <A>(
   return fromEffectContext(core.succeed(context))
 }
 
+/** @internal */
+export const empty = succeedContext(Context.empty())
+
 /** @internal */
 export const suspend = <RIn, E, ROut>(
   evaluate: LazyArg<Layer.Layer<RIn, E, ROut>>

package/src/internal/matcher.ts

@@ -366,15 +366,10 @@ export const discriminators = <D extends string>(field: D) =>
 >(
   fields: P
 ) => {
-  const predicates: Array<When> = []
-  for (const key in fields) {
-    const pred = (_: any) => _[field] === key
-    const f = fields[key]
-    if (f) {
-      predicates.push(makeWhen(pred, f as any))
-    }
-  }
-  const len = predicates.length
+  const predicate = makeWhen(
+    (_: any) => _[field] in fields,
+    (data: any) => (fields as any)[data[field]](data)
+  )
 
   return <I, F, A, Pr>(
     self: Matcher<I, F, R, A, Pr>
@@ -384,13 +379,7 @@ export const discriminators = <D extends string>(field: D) =>
     Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, keyof P>>>>,
     A | ReturnType<P[keyof P] & {}>,
     Pr
-  > => {
-    let matcher: any = self
-    for (let i = 0; i < len; i++) {
-      matcher = matcher.add(predicates[i])
-    }
-    return matcher
-  }
+  > => (self as any).add(predicate)
 }
 
 /** @internal */
@@ -532,6 +521,17 @@ export const either: <I, F, R, A, Pr>(
     }
 
     const len = self.cases.length
+    if (len === 1) {
+      const _case = self.cases[0]
+      return (input: I): Either.Either<RA, A> => {
+        if (_case._tag === "When" && _case.guard(input) === true) {
+          return Either.right(_case.evaluate(input))
+        } else if (_case._tag === "Not" && _case.guard(input) === false) {
+          return Either.right(_case.evaluate(input))
+        }
+        return Either.left(input as any)
+      }
+    }
     return (input: I): Either.Either<RA, A> => {
       for (let i = 0; i < len; i++) {
         const _case = self.cases[i]

package/src/internal/metric.ts

@@ -308,9 +308,9 @@ export const timer = (name: string, description?: string): Metric.Metric<
   MetricState.MetricState.Histogram
 > => {
   const boundaries = metricBoundaries.exponential({
-    start: 1,
+    start: 0.5,
     factor: 2,
-    count: 100
+    count: 35
   })
   const base = pipe(histogram(name, boundaries, description), tagged("time_unit", "milliseconds"))
   return mapInput(base, Duration.toMillis)

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.0.0-next.60"
+export const moduleVersion = "2.0.0-next.62"