effect 3.4.8 → 3.5.0

package/src/index.ts

@@ -605,6 +605,16 @@ export * as Random from "./Random.js"
  */
 export * as RateLimiter from "./RateLimiter.js"
 
+/**
+ * @since 3.5.0
+ */
+export * as RcMap from "./RcMap.js"
+
+/**
+ * @since 3.5.0
+ */
+export * as RcRef from "./RcRef.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/cause.ts

@@ -970,25 +970,46 @@ export const reduceWithContext = dual<
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const pretty = <E>(cause: Cause.Cause<E>): string => {
+export const pretty = <E>(cause: Cause.Cause<E>, options?: {
+  readonly renderErrorCause?: boolean | undefined
+}): string => {
   if (isInterruptedOnly(cause)) {
     return "All fibers interrupted without errors."
   }
-  return prettyErrors<E>(cause).map((e) => e.stack).join("\n")
+  return prettyErrors<E>(cause).map(function(e) {
+    if (options?.renderErrorCause !== true || e.cause === undefined) {
+      return e.stack
+    }
+    return `${e.stack} {\n${renderErrorCause(e.cause as PrettyError, "  ")}\n}`
+  }).join("\n")
+}
+
+const renderErrorCause = (cause: PrettyError, prefix: string) => {
+  const lines = cause.stack!.split("\n")
+  let stack = `${prefix}[cause]: ${lines[0]}`
+  for (let i = 1, len = lines.length; i < len; i++) {
+    stack += `\n${prefix}${lines[i]}`
+  }
+  return stack
 }
 
 class PrettyError extends globalThis.Error implements Cause.PrettyError {
   span: undefined | Span = undefined
   constructor(originalError: unknown) {
+    const originalErrorIsObject = typeof originalError === "object" && originalError !== null
     const prevLimit = Error.stackTraceLimit
-    Error.stackTraceLimit = 0
-    super(prettyErrorMessage(originalError))
+    Error.stackTraceLimit = 1
+    super(prettyErrorMessage(originalError), {
+      cause: originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined"
+        ? new PrettyError(originalError.cause)
+        : undefined
+    })
     if (this.message === "") {
       this.message = "An error has occurred"
     }
     Error.stackTraceLimit = prevLimit
     this.name = originalError instanceof Error ? originalError.name : "Error"
-    if (typeof originalError === "object" && originalError !== null) {
+    if (originalErrorIsObject) {
       if (spanSymbol in originalError) {
         this.span = originalError[spanSymbol] as Span
       }

package/src/internal/channel/channelExecutor.ts

@@ -1095,7 +1095,7 @@ export const readUpstream = <A, E2, R, E>(
 /** @internal */
 export const run = <Env, InErr, InDone, OutErr, OutDone>(
   self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => pipe(runScoped(self), Effect.scoped)
+): Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> => pipe(runScoped(self), Effect.scoped)
 
 /** @internal */
 export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(

package/src/internal/channel.ts

@@ -2052,17 +2052,18 @@ export const repeated = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
 /** @internal */
 export const run = <OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => Effect.scoped(executor.runScoped(self))
+): Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> => Effect.scoped(executor.runScoped(self))
 
 /** @internal */
 export const runCollect = <OutElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<[Chunk.Chunk<OutElem>, OutDone], OutErr, Env> => executor.run(core.collectElements(self))
+): Effect.Effect<[Chunk.Chunk<OutElem>, OutDone], OutErr, Exclude<Env, Scope.Scope>> =>
+  executor.run(core.collectElements(self))
 
 /** @internal */
 export const runDrain = <OutElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => executor.run(drain(self))
+): Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> => executor.run(drain(self))
 
 /** @internal */
 export const scoped = <A, E, R>(

package/src/internal/core-effect.ts

@@ -911,11 +911,6 @@ export const logWithLevel = (level?: LogLevel.LogLevel) =>
       i--
     }
   }
-  if (message.length === 0) {
-    message = "" as any
-  } else if (message.length === 1) {
-    message = message[0]
-  }
   if (cause === undefined) {
     cause = internalCause.empty
   }

package/src/internal/core.ts

@@ -2174,23 +2174,19 @@ export const causeSquashWith = dual<
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const YieldableError: new(message?: string) => Cause.YieldableError = (function() {
+export const YieldableError: new(message?: string, options?: ErrorOptions) => Cause.YieldableError = (function() {
   class YieldableError extends globalThis.Error {
     commit() {
       return fail(this)
     }
-    toString() {
-      return this.message ? `${this.name}: ${this.message}` : this.name
-    }
     toJSON() {
       return { ...this }
     }
-    [NodeInspectSymbol](): string {
-      const stack = this.stack
-      if (stack) {
-        return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`
+    [NodeInspectSymbol]() {
+      if (this.toString !== globalThis.Error.prototype.toString) {
+        return this.stack ? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}` : this.toString()
       }
-      return this.toString()
+      return this
     }
   }
   Object.assign(YieldableError.prototype, StructuralCommitPrototype)
@@ -2274,6 +2270,20 @@ export const InvalidPubSubCapacityException = makeException<Cause.InvalidPubSubC
   [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
 }, "InvalidPubSubCapacityException")
 
+/** @internal */
+export const ExceededCapacityExceptionTypeId: Cause.ExceededCapacityExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/ExceededCapacityException"
+) as Cause.ExceededCapacityExceptionTypeId
+
+/** @internal */
+export const ExceededCapacityException = makeException<Cause.ExceededCapacityException>({
+  [ExceededCapacityExceptionTypeId]: ExceededCapacityExceptionTypeId
+}, "ExceededCapacityException")
+
+/** @internal */
+export const isExceededCapacityException = (u: unknown): u is Cause.ExceededCapacityException =>
+  hasProperty(u, ExceededCapacityExceptionTypeId)
+
 /** @internal */
 export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException =>
   hasProperty(u, InvalidPubSubCapacityExceptionTypeId)

package/src/internal/defaultServices.ts

@@ -22,7 +22,7 @@ export const liveServices: Context.Context<DefaultServices.DefaultServices> = pi
   Context.empty(),
   Context.add(clock.clockTag, clock.make()),
   Context.add(console_.consoleTag, console_.defaultConsole),
-  Context.add(random.randomTag, random.make((Math.random() * 4294967296) >>> 0)),
+  Context.add(random.randomTag, random.make(Math.random())),
   Context.add(configProvider.configProviderTag, configProvider.fromEnv()),
   Context.add(tracer.tracerTag, tracer.nativeTracer)
 )

package/src/internal/fiberRuntime.ts

@@ -1421,6 +1421,12 @@ export const logFmtLogger: Logger<unknown, void> = globalValue(
   () => loggerWithConsoleLog(internalLogger.logfmtLogger)
 )
 
+/** @internal */
+export const prettyLogger: Logger<unknown, void> = globalValue(
+  Symbol.for("effect/Logger/prettyLogger"),
+  () => internalLogger.prettyLogger()
+)
+
 /** @internal */
 export const structuredLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/structuredLogger"),

package/src/internal/logger.ts

@@ -1,3 +1,6 @@
+import * as Arr from "../Array.js"
+import * as Context from "../Context.js"
+import * as FiberRefs from "../FiberRefs.js"
 import type { LazyArg } from "../Function.js"
 import { constVoid, dual, pipe } from "../Function.js"
 import * as HashMap from "../HashMap.js"
@@ -9,6 +12,8 @@ import * as LogSpan from "../LogSpan.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Cause from "./cause.js"
+import * as defaultServices from "./defaultServices.js"
+import { consoleTag } from "./defaultServices/console.js"
 import * as _fiberId from "./fiberId.js"
 
 /** @internal */
@@ -157,7 +162,7 @@ export const zipRight = dual<
 >(2, (self, that) => map(zip(self, that), (tuple) => tuple[1]))
 
 /** @internal */
-export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown, string>(
+export const stringLogger: Logger.Logger<unknown, string> = makeLogger(
   ({ annotations, cause, date, fiberId, logLevel, message, spans }) => {
     const nowMillis = date.getTime()
 
@@ -169,16 +174,9 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
 
     let output = outputArray.join(" ")
 
-    if (Array.isArray(message)) {
-      for (let i = 0; i < message.length; i++) {
-        const stringMessage = Inspectable.toStringUnknown(message[i])
-        if (stringMessage.length > 0) {
-          output = output + " message="
-          output = appendQuoted(stringMessage, output)
-        }
-      }
-    } else {
-      const stringMessage = Inspectable.toStringUnknown(message)
+    const messageArr = Arr.ensure(message)
+    for (let i = 0; i < messageArr.length; i++) {
+      const stringMessage = Inspectable.toStringUnknown(messageArr[i])
       if (stringMessage.length > 0) {
         output = output + " message="
         output = appendQuoted(stringMessage, output)
@@ -187,7 +185,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
 
     if (cause != null && cause._tag !== "Empty") {
       output = output + " cause="
-      output = appendQuoted(Cause.pretty(cause), output)
+      output = appendQuoted(Cause.pretty(cause, { renderErrorCause: true }), output)
     }
 
     if (List.isCons(spans)) {
@@ -204,7 +202,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
       }
     }
 
-    if (pipe(annotations, HashMap.size) > 0) {
+    if (HashMap.size(annotations) > 0) {
       output = output + " "
 
       let first = true
@@ -246,16 +244,9 @@ export const logfmtLogger = makeLogger<unknown, string>(
 
     let output = outputArray.join(" ")
 
-    if (Array.isArray(message)) {
-      for (let i = 0; i < message.length; i++) {
-        const stringMessage = Inspectable.toStringUnknown(message[i], 0)
-        if (stringMessage.length > 0) {
-          output = output + " message="
-          output = appendQuotedLogfmt(stringMessage, output)
-        }
-      }
-    } else {
-      const stringMessage = Inspectable.toStringUnknown(message, 0)
+    const messageArr = Arr.ensure(message)
+    for (let i = 0; i < messageArr.length; i++) {
+      const stringMessage = Inspectable.toStringUnknown(messageArr[i], 0)
       if (stringMessage.length > 0) {
         output = output + " message="
         output = appendQuotedLogfmt(stringMessage, output)
@@ -264,7 +255,7 @@ export const logfmtLogger = makeLogger<unknown, string>(
 
     if (cause != null && cause._tag !== "Empty") {
       output = output + " cause="
-      output = appendQuotedLogfmt(Cause.pretty(cause), output)
+      output = appendQuotedLogfmt(Cause.pretty(cause, { renderErrorCause: true }), output)
     }
 
     if (List.isCons(spans)) {
@@ -281,7 +272,7 @@ export const logfmtLogger = makeLogger<unknown, string>(
       }
     }
 
-    if (pipe(annotations, HashMap.size) > 0) {
+    if (HashMap.size(annotations) > 0) {
       output = output + " "
 
       let first = true
@@ -328,11 +319,12 @@ export const structuredLogger = makeLogger<unknown, {
       }
     }
 
+    const messageArr = Arr.ensure(message)
     return {
-      message: structuredMessage(message),
+      message: messageArr.length === 1 ? structuredMessage(messageArr[0]) : messageArr.map(structuredMessage),
       logLevel: logLevel.label,
       timestamp: date.toISOString(),
-      cause: Cause.isEmpty(cause) ? undefined : Cause.pretty(cause),
+      cause: Cause.isEmpty(cause) ? undefined : Cause.pretty(cause, { renderErrorCause: true }),
       annotations: annotationsObj,
       spans: spansObj,
       fiberId: _fiberId.threadName(fiberId)
@@ -376,3 +368,117 @@ const renderLogSpanLogfmt = (now: number) => (self: LogSpan.LogSpan): string =>
 export const isLogger = (u: unknown): u is Logger.Logger<unknown, unknown> => {
   return typeof u === "object" && u != null && LoggerTypeId in u
 }
+
+const processStdoutIsTTY = typeof process === "object" && "stdout" in process && process.stdout.isTTY === true
+const hasWindow = typeof window === "object"
+
+const withColor = (text: string, ...colors: ReadonlyArray<string>) => {
+  let out = ""
+  for (let i = 0; i < colors.length; i++) {
+    out += `\x1b[${colors[i]}m`
+  }
+  return out + text + "\x1b[0m"
+}
+const withColorNoop = (text: string, ..._colors: ReadonlyArray<string>) => text
+const colors = {
+  bold: "1",
+  red: "31",
+  green: "32",
+  yellow: "33",
+  blue: "34",
+  cyan: "36",
+  white: "37",
+  gray: "90",
+  black: "30",
+  bgBrightRed: "101"
+} as const
+
+const logLevelColors: Record<LogLevel.LogLevel["_tag"], ReadonlyArray<string>> = {
+  None: [],
+  All: [],
+  Trace: [colors.gray],
+  Debug: [colors.blue],
+  Info: [colors.green],
+  Warning: [colors.yellow],
+  Error: [colors.red],
+  Fatal: [colors.bgBrightRed, colors.black]
+}
+
+const defaultDateFormat = (date: Date): string =>
+  `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}:${
+    date.getSeconds().toString().padStart(2, "0")
+  }.${date.getMilliseconds().toString().padStart(3, "0")}`
+
+/** @internal */
+export const prettyLogger = (options?: {
+  readonly colors?: "auto" | boolean | undefined
+  readonly stderr?: boolean | undefined
+  readonly formatDate?: ((date: Date) => string) | undefined
+  readonly mode?: "browser" | "tty" | "auto" | undefined
+}) => {
+  const mode_ = options?.mode ?? "auto"
+  const mode = mode_ === "auto" ? (hasWindow ? "browser" : "tty") : mode_
+  const isBrowser = mode === "browser"
+  const showColors = typeof options?.colors === "boolean" ? options.colors : processStdoutIsTTY || isBrowser
+  const color = showColors ? withColor : withColorNoop
+  const formatDate = options?.formatDate ?? defaultDateFormat
+
+  return makeLogger<unknown, void>(
+    ({ annotations, cause, context, date, fiberId, logLevel, message: message_, spans }) => {
+      const services = FiberRefs.getOrDefault(context, defaultServices.currentServices)
+      const console = Context.get(services, consoleTag).unsafe
+      const log = options?.stderr === true ? console.error : console.log
+
+      const message = Arr.ensure(message_)
+
+      let firstLine = color(`[${formatDate(date)}]`, colors.white)
+        + ` ${color(logLevel.label, ...logLevelColors[logLevel._tag])}`
+        + ` (${_fiberId.threadName(fiberId)})`
+
+      if (List.isCons(spans)) {
+        const now = date.getTime()
+        const render = renderLogSpanLogfmt(now)
+        for (const span of spans) {
+          firstLine += " " + render(span)
+        }
+      }
+
+      firstLine += ":"
+      let messageIndex = 0
+      if (message.length > 0) {
+        const firstMaybeString = structuredMessage(message[0])
+        if (typeof firstMaybeString === "string") {
+          firstLine += " " + color(firstMaybeString, colors.bold, colors.cyan)
+          messageIndex++
+        }
+      }
+
+      if (isBrowser) {
+        console.groupCollapsed(firstLine)
+      } else {
+        log(firstLine)
+        console.group()
+      }
+      if (!Cause.isEmpty(cause)) {
+        if (isBrowser) {
+          console.error(Cause.pretty(cause, { renderErrorCause: true }))
+        } else {
+          log(Cause.pretty(cause, { renderErrorCause: true }))
+        }
+      }
+
+      if (messageIndex < message.length) {
+        for (; messageIndex < message.length; messageIndex++) {
+          log(message[messageIndex])
+        }
+      }
+
+      if (HashMap.size(annotations) > 0) {
+        for (const [key, value] of annotations) {
+          log(color(`${key}:`, colors.bold, colors.white), value)
+        }
+      }
+      console.groupEnd()
+    }
+  )
+}

package/src/internal/pool.ts

@@ -5,6 +5,7 @@ import type { Effect, Semaphore } from "../Effect.js"
 import type { Exit } from "../Exit.js"
 import { dual, identity } from "../Function.js"
 import * as Iterable from "../Iterable.js"
+import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Pool, PoolTypeId as PoolTypeId_ } from "../Pool.js"
 import { hasProperty } from "../Predicate.js"
@@ -112,11 +113,13 @@ interface PoolItem<A, E> {
   readonly exit: Exit<A, E>
   finalizer: Effect<void>
   refCount: number
+  disableReclaim: boolean
 }
 
 interface Strategy<A, E> {
   readonly run: (pool: PoolImpl<A, E>) => Effect<void>
   readonly onAcquire: (item: PoolItem<A, E>) => Effect<void>
+  readonly reclaim: (pool: PoolImpl<A, E>) => Effect<Option.Option<PoolItem<A, E>>>
 }
 
 class PoolImpl<A, E> implements Pool<A, E> {
@@ -151,7 +154,8 @@ class PoolImpl<A, E> implements Pool<A, E> {
           const item: PoolItem<A, E> = {
             exit,
             finalizer: core.catchAllCause(scope.close(exit), reportUnhandledError),
-            refCount: 0
+            refCount: 0,
+            disableReclaim: false
           }
           this.items.add(item)
           this.available.add(item)
@@ -189,7 +193,13 @@ class PoolImpl<A, E> implements Pool<A, E> {
     if (this.activeSize >= this.targetSize) {
       return core.void
     }
-    return core.zipRight(this.allocate, this.resizeLoop)
+    return this.strategy.reclaim(this).pipe(
+      core.flatMap(Option.match({
+        onNone: () => this.allocate,
+        onSome: core.succeed
+      })),
+      core.zipRight(this.resizeLoop)
+    )
   })
   readonly resizeSemaphore = circular.unsafeMakeSemaphore(1)
   readonly resize = this.resizeSemaphore.withPermits(1)(this.resizeLoop)
@@ -253,6 +263,7 @@ class PoolImpl<A, E> implements Pool<A, E> {
       if (this.isShuttingDown) return core.void
       for (const poolItem of this.items) {
         if (poolItem.exit._tag === "Success" && poolItem.exit.value === item) {
+          poolItem.disableReclaim = true
           return core.uninterruptible(this.invalidatePoolItem(poolItem))
         }
       }
@@ -306,7 +317,8 @@ class PoolImpl<A, E> implements Pool<A, E> {
 
 const strategyNoop = <A, E>(): Strategy<A, E> => ({
   run: (_) => core.void,
-  onAcquire: (_) => core.void
+  onAcquire: (_) => core.void,
+  reclaim: (_) => coreEffect.succeedNone
 })
 
 const strategyCreationTTL = <A, E>(ttl: Duration.DurationInput) =>
@@ -337,7 +349,8 @@ const strategyCreationTTL = <A, E>(ttl: Duration.DurationInput) =>
           core.suspend(() => {
             creationTimes.set(item, clock.unsafeCurrentTimeMillis())
             return queue.offer(item)
-          })
+          }),
+        reclaim: (_) => coreEffect.succeedNone
       })
     })
   )
@@ -359,7 +372,25 @@ const strategyUsageTTL = <A, E>(ttl: Duration.DurationInput) =>
           coreEffect.forever
         )
       },
-      onAcquire: (item) => queue.offer(item)
+      onAcquire: (item) => queue.offer(item),
+      reclaim(pool) {
+        return core.suspend((): Effect<Option.Option<PoolItem<A, E>>> => {
+          if (pool.invalidated.size === 0) {
+            return coreEffect.succeedNone
+          }
+          const item = Iterable.head(
+            Iterable.filter(pool.invalidated, (item) => !item.disableReclaim)
+          )
+          if (item._tag === "None") {
+            return coreEffect.succeedNone
+          }
+          pool.invalidated.delete(item.value)
+          if (item.value.refCount < pool.concurrency) {
+            pool.available.add(item.value)
+          }
+          return core.as(queue.offer(item.value), item)
+        })
+      }
     })
   })