effect 2.0.0-next.50 → 2.0.0-next.52

package/src/index.ts

@@ -29,6 +29,23 @@ export {
   unsafeCoerce
 } from "effect/Function"
 
+/**
+ * This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript.
+ * It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`.
+ *
+ * A `BigDecimal` allows storing any real number to arbitrary precision; which avoids common floating point errors
+ * (such as 0.1 + 0.2 ≠ 0.3) at the cost of complexity.
+ *
+ * Internally, `BigDecimal` uses a `BigInt` object, paired with a 64-bit integer which determines the position of the
+ * decimal point. Therefore, the precision *is not* actually arbitrary, but limited to 2<sup>63</sup> decimal places.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly, as the floating point representation
+ * may be unexpected.
+ *
+ * @since 2.0.0
+ */
+export * as BigDecimal from "effect/BigDecimal"
+
 /**
  * This module provides utility functions and type class instances for working with the `bigint` type in TypeScript.
  * It includes functions for basic arithmetic operations, as well as type class instances for

package/src/internal/Data.ts

@@ -39,7 +39,8 @@ export const StructProto: Equal.Equal = {
 
 /** @internal */
 export const Structural: new<A>(
-  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends keyof Equal.Equal ? never : P]: A[P] }
 ) => Data.Case = (function() {
   function Structural(this: any, args: any) {
     if (args) {

package/src/internal/HashMap/node.ts

@@ -40,7 +40,7 @@ export class EmptyNode<K, V> {
 
 /** @internal */
 export function isEmptyNode(a: unknown): a is EmptyNode<unknown, unknown> {
-  return a instanceof EmptyNode
+  return typeof a === "object" && a !== null && "_tag" in a && a._tag === "EmptyNode"
 }
 
 /** @internal */

package/src/internal/fiberRuntime.ts

@@ -17,6 +17,7 @@ import * as FiberRefsPatch from "../FiberRefsPatch"
 import * as FiberStatus from "../FiberStatus"
 import type { LazyArg } from "../Function"
 import { dual, identity, pipe } from "../Function"
+import { globalValue } from "../GlobalValue"
 import * as HashMap from "../HashMap"
 import * as HashSet from "../HashSet"
 import * as _RequestBlock from "../internal/blockedRequests"
@@ -1335,8 +1336,9 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
 // circular with Logger
 
 /** @internal */
-export const currentMinimumLogLevel: FiberRef.FiberRef<LogLevel.LogLevel> = core.fiberRefUnsafeMake<LogLevel.LogLevel>(
-  LogLevel.fromLiteral("Info")
+export const currentMinimumLogLevel: FiberRef.FiberRef<LogLevel.LogLevel> = globalValue(
+  "effect/FiberRef/currentMinimumLogLevel",
+  () => core.fiberRefUnsafeMake<LogLevel.LogLevel>(LogLevel.fromLiteral("Info"))
 )
 
 /** @internal */
@@ -1347,60 +1349,69 @@ export const getConsole = (refs: FiberRefs.FiberRefs) => {
 }
 
 /** @internal */
-export const defaultLogger: Logger<unknown, void> = internalLogger.makeLogger((options) => {
-  const formatted = internalLogger.stringLogger.log(options)
-  getConsole(options.context).log(formatted)
-})
-
-/** @internal */
-export const filterMinimumLogLevel: Logger<unknown, void> = internalLogger.makeLogger((options) => {
-  const formatted = internalLogger.stringLogger.log(options)
-  getConsole(options.context).log(formatted)
-})
+export const defaultLogger: Logger<unknown, void> = globalValue(
+  Symbol.for("effect/Logger/defaultLogger"),
+  () =>
+    internalLogger.makeLogger((options) => {
+      const formatted = internalLogger.stringLogger.log(options)
+      getConsole(options.context).log(formatted)
+    })
+)
 
 /** @internal */
-export const logFmtLogger: Logger<unknown, void> = internalLogger.makeLogger((options) => {
-  const formatted = internalLogger.logfmtLogger.log(options)
-  getConsole(options.context).log(formatted)
-})
+export const logFmtLogger: Logger<unknown, void> = globalValue(
+  Symbol.for("effect/Logger/logFmtLogger"),
+  () =>
+    internalLogger.makeLogger((options) => {
+      const formatted = internalLogger.logfmtLogger.log(options)
+      getConsole(options.context).log(formatted)
+    })
+)
 
 /** @internal */
-export const tracerLogger = internalLogger.makeLogger<unknown, void>(({
-  annotations,
-  cause,
-  context,
-  fiberId,
-  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)
-  )
-  if (span._tag === "None" || span.value._tag === "ExternalSpan" || clockService._tag === "None") {
-    return
-  }
+export const tracerLogger = globalValue(
+  Symbol.for("effect/Logger/tracerLogger"),
+  () =>
+    internalLogger.makeLogger<unknown, void>(({
+      annotations,
+      cause,
+      context,
+      fiberId,
+      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)
+      )
+      if (span._tag === "None" || span.value._tag === "ExternalSpan" || clockService._tag === "None") {
+        return
+      }
 
-  const attributes = Object.fromEntries(HashMap.map(annotations, (value) => internalLogger.serializeUnknown(value)))
-  attributes["effect.fiberId"] = FiberId.threadName(fiberId)
-  attributes["effect.logLevel"] = logLevel.label
+      const attributes = Object.fromEntries(HashMap.map(annotations, (value) => internalLogger.serializeUnknown(value)))
+      attributes["effect.fiberId"] = FiberId.threadName(fiberId)
+      attributes["effect.logLevel"] = logLevel.label
 
-  if (cause !== null && cause._tag !== "Empty") {
-    attributes["effect.cause"] = internalCause.pretty(cause)
-  }
+      if (cause !== null && cause._tag !== "Empty") {
+        attributes["effect.cause"] = internalCause.pretty(cause)
+      }
 
-  span.value.event(
-    String(message),
-    clockService.value.unsafeCurrentTimeNanos(),
-    attributes
-  )
-})
+      span.value.event(
+        String(message),
+        clockService.value.unsafeCurrentTimeNanos(),
+        attributes
+      )
+    })
+)
 
 /** @internal */
 export const currentLoggers: FiberRef.FiberRef<
   HashSet.HashSet<Logger<unknown, any>>
-> = core.fiberRefUnsafeMakeHashSet(HashSet.make(defaultLogger, tracerLogger))
+> = globalValue(
+  Symbol.for("effect/FiberRef/currentLoggers"),
+  () => core.fiberRefUnsafeMakeHashSet(HashSet.make(defaultLogger, tracerLogger))
+)
 
 // circular with Effect
 

package/src/internal/query.ts

@@ -19,14 +19,18 @@ type RequestCache = Cache.Cache<Request.Request<any, any>, never, {
 }>
 
 /** @internal */
-export const currentCache = core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, never, {
-  listeners: Request.Listeners
-  handle: Deferred<any, any>
-}>(
-  65536,
-  () => core.map(core.deferredMake<any, any>(), (handle) => ({ listeners: new Listeners(), handle })),
-  () => seconds(60)
-))
+export const currentCache = globalValue(
+  Symbol.for("effect/FiberRef/currentCache"),
+  () =>
+    core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, never, {
+      listeners: Request.Listeners
+      handle: Deferred<any, any>
+    }>(
+      65536,
+      () => core.map(core.deferredMake<any, any>(), (handle) => ({ listeners: new Listeners(), handle })),
+      () => seconds(60)
+    ))
+)
 
 /** @internal */
 export const currentCacheEnabled = globalValue(

package/src/internal/supervisor/patch.ts

@@ -131,7 +131,7 @@ const removeSupervisor = (
   if (Equal.equals(self, that)) {
     return supervisor.none
   } else {
-    if (self instanceof supervisor.Zip) {
+    if (supervisor.isZip(self)) {
       return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that))
     } else {
       return self
@@ -144,7 +144,7 @@ const toSet = (self: Supervisor.Supervisor<any>): HashSet.HashSet<Supervisor.Sup
   if (Equal.equals(self, supervisor.none)) {
     return HashSet.empty()
   } else {
-    if (self instanceof supervisor.Zip) {
+    if (supervisor.isZip(self)) {
       return pipe(toSet(self.left), HashSet.union(toSet(self.right)))
     } else {
       return HashSet.make(self)

package/src/internal/supervisor.ts

@@ -73,6 +73,7 @@ export class ProxySupervisor<T> implements Supervisor.Supervisor<T> {
 
 /** @internal */
 export class Zip<T0, T1> implements Supervisor.Supervisor<readonly [T0, T1]> {
+  readonly _tag = "Zip"
   readonly [SupervisorTypeId] = supervisorVariance
 
   constructor(
@@ -124,6 +125,10 @@ export class Zip<T0, T1> implements Supervisor.Supervisor<readonly [T0, T1]> {
   }
 }
 
+export const isZip = (self: unknown): self is Zip<any, any> => {
+  return typeof self === "object" && self !== null && SupervisorTypeId in self && "_tag" in self && self._tag === "Zip"
+}
+
 export class Track implements Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any, any>>> {
   readonly [SupervisorTypeId] = supervisorVariance
 

package/src/tsconfig.json

@@ -8,7 +8,6 @@
     "skipLibCheck": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
-    "preserveSymlinks": true,
     "moduleResolution": "node",
     "noEmit": true,
     "lib": [