effect 3.4.9 → 3.5.1

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.4.9";
+let moduleVersion = "3.5.1";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.4.9",
+  "version": "3.5.1",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {
@@ -472,6 +472,16 @@
       "import": "./dist/esm/RateLimiter.js",
       "default": "./dist/cjs/RateLimiter.js"
     },
+    "./RcMap": {
+      "types": "./dist/dts/RcMap.d.ts",
+      "import": "./dist/esm/RcMap.js",
+      "default": "./dist/cjs/RcMap.js"
+    },
+    "./RcRef": {
+      "types": "./dist/dts/RcRef.d.ts",
+      "import": "./dist/esm/RcRef.js",
+      "default": "./dist/cjs/RcRef.js"
+    },
     "./Readable": {
       "types": "./dist/dts/Readable.d.ts",
       "import": "./dist/esm/Readable.js",
@@ -1085,6 +1095,12 @@
       "RateLimiter": [
         "./dist/dts/RateLimiter.d.ts"
       ],
+      "RcMap": [
+        "./dist/dts/RcMap.d.ts"
+      ],
+      "RcRef": [
+        "./dist/dts/RcRef.d.ts"
+      ],
       "Readable": [
         "./dist/dts/Readable.d.ts"
       ],

package/src/Cause.ts

@@ -111,6 +111,18 @@ export const InvalidPubSubCapacityExceptionTypeId: unique symbol = core.InvalidP
  */
 export type InvalidPubSubCapacityExceptionTypeId = typeof InvalidPubSubCapacityExceptionTypeId
 
+/**
+ * @since 3.5.0
+ * @category symbols
+ */
+export const ExceededCapacityExceptionTypeId: unique symbol = core.ExceededCapacityExceptionTypeId
+
+/**
+ * @since 3.5.0
+ * @category symbols
+ */
+export type ExceededCapacityExceptionTypeId = typeof ExceededCapacityExceptionTypeId
+
 /**
  * @since 2.0.0
  * @category symbols
@@ -264,6 +276,18 @@ export interface InvalidPubSubCapacityException extends YieldableError {
   readonly [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
 }
 
+/**
+ * Represents a checked exception which occurs when a resources capacity has
+ * been exceeded.
+ *
+ * @since 3.5.0
+ * @category models
+ */
+export interface ExceededCapacityException extends YieldableError {
+  readonly _tag: "ExceededCapacityException"
+  readonly [ExceededCapacityExceptionTypeId]: ExceededCapacityExceptionTypeId
+}
+
 /**
  * Represents a checked exception which occurs when a computation doesn't
  * finish on schedule.
@@ -907,13 +931,35 @@ export const UnknownException: new(error: unknown, message?: string | undefined)
  */
 export const isUnknownException: (u: unknown) => u is UnknownException = core.isUnknownException
 
+/**
+ * Represents a checked exception which occurs when a resources capacity has
+ * been exceeded.
+ *
+ * @since 3.5.0
+ * @category errors
+ */
+export const ExceededCapacityException: new(message?: string | undefined) => ExceededCapacityException =
+  core.ExceededCapacityException
+
+/**
+ * Returns `true` if the specified value is an `ExceededCapacityException`, `false`
+ * otherwise.
+ *
+ * @since 3.5.0
+ * @category refinements
+ */
+export const isExceededCapacityException: (u: unknown) => u is ExceededCapacityException =
+  core.isExceededCapacityException
+
 /**
  * Returns the specified `Cause` as a pretty-printed string.
  *
  * @since 2.0.0
  * @category rendering
  */
-export const pretty: <E>(cause: Cause<E>) => string = internal.pretty
+export const pretty: <E>(cause: Cause<E>, options?: {
+  readonly renderErrorCause?: boolean | undefined
+}) => string = internal.pretty
 
 /**
  * @since 3.2.0

package/src/Channel.ts

@@ -1916,7 +1916,7 @@ export const repeated: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
  */
 export const run: <OutErr, InErr, OutDone, InDone, Env>(
   self: Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-) => Effect.Effect<OutDone, OutErr, Env> = channel.run
+) => Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> = channel.run
 
 /**
  * Run the channel until it finishes with a done value or fails with an error
@@ -1929,7 +1929,7 @@ export const run: <OutErr, InErr, OutDone, InDone, Env>(
  */
 export const runCollect: <OutElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
-) => Effect.Effect<[Chunk.Chunk<OutElem>, OutDone], OutErr, Env> = channel.runCollect
+) => Effect.Effect<[Chunk.Chunk<OutElem>, OutDone], OutErr, Exclude<Env, Scope.Scope>> = channel.runCollect
 
 /**
  * Runs a channel until the end is received.
@@ -1939,7 +1939,7 @@ export const runCollect: <OutElem, OutErr, InErr, OutDone, InDone, Env>(
  */
 export const runDrain: <OutElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
-) => Effect.Effect<OutDone, OutErr, Env> = channel.runDrain
+) => Effect.Effect<OutDone, OutErr, Exclude<Env, Scope.Scope>> = channel.runDrain
 
 /**
  * Use a scoped effect to emit an output element.

package/src/Config.ts

@@ -51,6 +51,12 @@ export declare namespace Config {
     }
   }
 
+  /**
+   * @since 2.5.0
+   * @category models
+   */
+  export type Success<T extends Config<any>> = [T] extends [Config<infer _A>] ? _A : never
+
   /**
    * @since 2.0.0
    * @category models

package/src/Console.ts

@@ -63,10 +63,8 @@ export interface UnsafeConsole {
   dir(item: any, options?: any): void
   dirxml(...args: ReadonlyArray<any>): void
   error(...args: ReadonlyArray<any>): void
-  group(options?: {
-    readonly label?: string | undefined
-    readonly collapsed?: boolean | undefined
-  }): void
+  group(label?: string | undefined): void
+  groupCollapsed(label?: string | undefined): void
   groupEnd(): void
   info(...args: ReadonlyArray<any>): void
   log(...args: ReadonlyArray<any>): void

package/src/Data.ts

@@ -532,7 +532,7 @@ export const Error: new<A extends Record<string, any> = {}>(
 ) => Cause.YieldableError & Readonly<A> = (function() {
   return class Base extends core.YieldableError {
     constructor(args: any) {
-      super()
+      super(args?.message, { cause: args?.cause })
       if (args) {
         Object.assign(this, args)
       }

package/src/Duration.ts

@@ -200,6 +200,24 @@ export const isDuration = (u: unknown): u is Duration => hasProperty(u, TypeId)
  */
 export const isFinite = (self: Duration): boolean => self.value._tag !== "Infinity"
 
+/**
+ * @since 3.5.0
+ * @category guards
+ */
+export const isZero = (self: Duration): boolean => {
+  switch (self.value._tag) {
+    case "Millis": {
+      return self.value.millis === 0
+    }
+    case "Nanos": {
+      return self.value.nanos === bigint0
+    }
+    case "Infinity": {
+      return false
+    }
+  }
+}
+
 /**
  * @since 2.0.0
  * @category constructors

package/src/Effect.ts

@@ -4798,9 +4798,25 @@ export const matchEffect: {
 // -------------------------------------------------------------------------------------
 
 /**
- * Logs the specified message or cause at the current log level.
+ * Logs one or more messages or error causes at the current log level, which is INFO by default.
+ * This function allows logging multiple items at once and can include detailed error information using `Cause` instances.
  *
- * You can set the current log level using `FiberRef.currentLogLevel`.
+ * To adjust the log level, use the `Logger.withMinimumLogLevel` function.
+ *
+ * @example
+ * import { Cause, Effect } from "effect"
+ *
+ * const program = Effect.log(
+ *   "message1",
+ *   "message2",
+ *   Cause.die("Oh no!"),
+ *   Cause.die("Oh uh!")
+ * )
+ *
+ * // Effect.runFork(program)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#0 message=message1 message=message2 cause="Error: Oh no!
+ * // Error: Oh uh!"
  *
  * @since 2.0.0
  * @category logging
@@ -4827,7 +4843,19 @@ export const logWithLevel = (
 export const logTrace: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logTrace
 
 /**
- * Logs the specified message or cause at the Debug log level.
+ * Logs the specified messages at the DEBUG log level.
+ * DEBUG messages are not shown by default.
+ *
+ * To view DEBUG messages, adjust the logging settings using
+ * `Logger.withMinimumLogLevel` and set the log level to `LogLevel.Debug`.
+ *
+ * @example
+ * import { Effect, Logger, LogLevel } from "effect"
+ *
+ * const program = Effect.logDebug("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Debug))
+ *
+ * // Effect.runFork(program)
+ * // timestamp=... level=DEBUG fiber=#0 message=message1
  *
  * @since 2.0.0
  * @category logging
@@ -4867,7 +4895,20 @@ export const logError: (...message: ReadonlyArray<any>) => Effect<void, never, n
 export const logFatal: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logFatal
 
 /**
- * Adjusts the label for the current logging span.
+ * Adds a log span to your effects, which tracks and logs the duration of
+ * operations or tasks. This is useful for performance monitoring and debugging
+ * time-sensitive processes.
+ *
+ * @example
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.sleep("1 second")
+ *   yield* Effect.log("The job is finished!")
+ * }).pipe(Effect.withLogSpan("myspan"))
+ *
+ * // Effect.runFork(program)
+ * // timestamp=... level=INFO fiber=#0 message="The job is finished!" myspan=1011ms
  *
  * @since 2.0.0
  * @category logging
@@ -4878,7 +4919,21 @@ export const withLogSpan: {
 } = effect.withLogSpan
 
 /**
- * Annotates each log in this effect with the specified log annotation.
+ * Augments log outputs by appending custom annotations to log entries generated
+ * within an effect. This function provides a way to add more context and detail
+ * to log messages, making them more informative and easier to trace.
+ *
+ * @example
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("message1")
+ *   yield* Effect.log("message2")
+ * }).pipe(Effect.annotateLogs("key", "value")) // Annotation as key/value pair
+ *
+ * // Effect.runFork(program)
+ * // timestamp=... level=INFO fiber=#0 message=message1 key=value
+ * // timestamp=... level=INFO fiber=#0 message=message2 key=value
  *
  * @since 2.0.0
  * @category logging
@@ -4891,21 +4946,29 @@ export const annotateLogs: {
 } = effect.annotateLogs
 
 /**
- * Annotates each log with the specified log annotation(s), until the Scope is closed.
+ * Applies log annotations with a limited scope, restricting their appearance to
+ * specific sections of your effect computations. Use
+ * `Effect.annotateLogsScoped` to add metadata to logs that only appear within a
+ * defined `Scope`, making it easier to manage context-specific logging.
  *
- * @since 3.1.0
- * @category logging
  * @example
  * import { Effect } from "effect"
  *
- * Effect.gen(function*() {
+ * const program = Effect.gen(function*() {
  *   yield* Effect.log("no annotations")
- *   yield* Effect.annotateLogsScoped({ foo: "bar" })
- *   yield* Effect.log("annotated with foo=bar")
- * }).pipe(
- *   Effect.scoped,
- *   Effect.andThen(Effect.log("no annotations again"))
- * )
+ *   yield* Effect.annotateLogsScoped({ key: "value" })
+ *   yield* Effect.log("message1") // Annotation is applied to this log
+ *   yield* Effect.log("message2") // Annotation is applied to this log
+ * }).pipe(Effect.scoped, Effect.andThen(Effect.log("no annotations again")))
+ *
+ * // Effect.runFork(program)
+ * // timestamp=... level=INFO fiber=#0 message="no annotations"
+ * // timestamp=... level=INFO fiber=#0 message=message1 key=value
+ * // timestamp=... level=INFO fiber=#0 message=message2 key=value
+ * // timestamp=... level=INFO fiber=#0 message="no annotations again"
+ *
+ * @since 3.1.0
+ * @category logging
  */
 export const annotateLogsScoped: {
   (key: string, value: unknown): Effect<void, never, Scope.Scope>

package/src/Logger.ts

@@ -73,6 +73,35 @@ export declare namespace Logger {
 }
 
 /**
+ * Creates a custom logger that formats log messages according to the provided
+ * function.
+ *
+ * @example
+ * import { Effect, Logger, LogLevel } from "effect"
+ *
+ * const logger = Logger.make(({ logLevel, message }) => {
+ *   globalThis.console.log(`[${logLevel.label}] ${message}`)
+ * })
+ *
+ * const task1 = Effect.logDebug("task1 done")
+ * const task2 = Effect.logDebug("task2 done")
+ *
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("start")
+ *   yield* task1
+ *   yield* task2
+ *   yield* Effect.log("done")
+ * }).pipe(
+ *   Logger.withMinimumLogLevel(LogLevel.Debug),
+ *   Effect.provide(Logger.replace(Logger.defaultLogger, logger))
+ * )
+ *
+ * // Effect.runFork(program)
+ * // [INFO] start
+ * // [DEBUG] task1 done
+ * // [DEBUG] task2 done
+ * // [INFO] done
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -160,25 +189,36 @@ export const map: {
 } = internal.map
 
 /**
- * @since 2.0.0
- * @category mapping
+ * Creates a batched logger that groups log messages together and processes them
+ * in intervals.
+ *
+ * @param window - The time window in which to batch log messages.
+ *
  * @example
- * import { Console, Effect, Logger } from "effect";
+ * import { Console, Effect, Logger } from "effect"
  *
  * const LoggerLive = Logger.replaceScoped(
  *   Logger.defaultLogger,
  *   Logger.logfmtLogger.pipe(
- *     Logger.batched("500 millis", (messages) =>
- *       Console.log("BATCH", messages.join("\n"))
- *     )
+ *     Logger.batched("500 millis", (messages) => Console.log("BATCH", `[\n${messages.join("\n")}\n]`))
  *   )
- * );
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("one")
+ *   yield* Effect.log("two")
+ *   yield* Effect.log("three")
+ * }).pipe(Effect.provide(LoggerLive))
+ *
+ * // Effect.runFork(program)
+ * // BATCH [
+ * // timestamp=... level=INFO fiber=#0 message=one
+ * // timestamp=... level=INFO fiber=#0 message=two
+ * // timestamp=... level=INFO fiber=#0 message=three
+ * // ]
  *
- * Effect.gen(function* (_) {
- *   yield* _(Effect.log("one"));
- *   yield* _(Effect.log("two"));
- *   yield* _(Effect.log("three"));
- * }).pipe(Effect.provide(LoggerLive), Effect.runFork);
+ * @since 2.0.0
+ * @category mapping
  */
 export const batched: {
   <Output, R>(
@@ -278,6 +318,17 @@ export const test: {
 } = internalCircular.test
 
 /**
+ * Sets the minimum log level for subsequent logging operations, allowing
+ * control over which log messages are displayed based on their severity.
+ *
+ * @example
+ * import { Effect, Logger, LogLevel } from "effect"
+ *
+ * const program = Effect.logDebug("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Debug))
+ *
+ * // Effect.runFork(program)
+ * // timestamp=... level=DEBUG fiber=#0 message=message1
+ *
  * @since 2.0.0
  * @category context
  */
@@ -345,12 +396,40 @@ export const zipRight: {
 export const defaultLogger: Logger<unknown, void> = fiberRuntime.defaultLogger
 
 /**
+ * The `jsonLogger` logger formats log entries as JSON objects, making them easy to
+ * integrate with logging systems that consume JSON data.
+ *
+ * @example
+ * import { Effect, Logger } from "effect"
+ *
+ * const program = Effect.log("message1", "message2").pipe(
+ *   Effect.annotateLogs({ key1: "value1", key2: "value2" }),
+ *   Effect.withLogSpan("myspan")
+ * )
+ *
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.json)))
+ * // {"message":["message1","message2"],"logLevel":"INFO","timestamp":"...","annotations":{"key2":"value2","key1":"value1"},"spans":{"myspan":0},"fiberId":"#0"}
+ *
  * @since 2.0.0
  * @category constructors
  */
 export const jsonLogger: Logger<unknown, string> = internal.jsonLogger
 
 /**
+ * This logger outputs logs in a human-readable format that is easy to read
+ * during development or in a production console.
+ *
+ * @example
+ * import { Effect, Logger } from "effect"
+ *
+ * const program = Effect.log("message1", "message2").pipe(
+ *   Effect.annotateLogs({ key1: "value1", key2: "value2" }),
+ *   Effect.withLogSpan("myspan")
+ * )
+ *
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.logFmt)))
+ * // timestamp=... level=INFO fiber=#0 message=message1 message=message2 myspan=0ms key2=value2 key1=value1
+ *
  * @since 2.0.0
  * @category constructors
  */
@@ -363,6 +442,63 @@ export const logfmtLogger: Logger<unknown, string> = internal.logfmtLogger
 export const stringLogger: Logger<unknown, string> = internal.stringLogger
 
 /**
+ * The pretty logger utilizes the capabilities of the console API to generate
+ * visually engaging and color-enhanced log outputs. This feature is
+ * particularly useful for improving the readability of log messages during
+ * development and debugging processes.
+ *
+ * @example
+ * import { Effect, Logger } from "effect"
+ *
+ * const program = Effect.log("message1", "message2").pipe(
+ *   Effect.annotateLogs({ key1: "value1", key2: "value2" }),
+ *   Effect.withLogSpan("myspan")
+ * )
+ *
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.pretty)))
+ * //         green --v                      v-- bold and cyan
+ * // [07:51:54.434] INFO (#0) myspan=1ms: message1
+ * //   message2
+ * //    v-- bold
+ * //   key2: value2
+ * //   key1: value1
+ *
+ * @since 3.5.0
+ * @category constructors
+ */
+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
+  }
+) => Logger<unknown, void> = internal.prettyLogger
+
+/**
+ * The structured logger provides detailed log outputs, structured in a way that
+ * retains comprehensive traceability of the events, suitable for deeper
+ * analysis and troubleshooting.
+ *
+ * @example
+ * import { Effect, Logger } from "effect"
+ *
+ * const program = Effect.log("message1", "message2").pipe(
+ *   Effect.annotateLogs({ key1: "value1", key2: "value2" }),
+ *   Effect.withLogSpan("myspan")
+ * )
+ *
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.structured)))
+ * // {
+ * //   message: [ 'message1', 'message2' ],
+ * //   logLevel: 'INFO',
+ * //   timestamp: '2024-07-09T14:05:41.623Z',
+ * //   cause: undefined,
+ * //   annotations: { key2: 'value2', key1: 'value1' },
+ * //   spans: { myspan: 0 },
+ * //   fiberId: '#0'
+ * // }
+ *
  * @since 2.0.0
  * @category constructors
  */
@@ -386,24 +522,118 @@ export const structuredLogger: Logger<
 export const tracerLogger: Logger<unknown, void> = fiberRuntime.tracerLogger
 
 /**
+ * The `json` logger formats log entries as JSON objects, making them easy to
+ * integrate with logging systems that consume JSON data.
+ *
+ * @example
+ * import { Effect, Logger } from "effect"
+ *
+ * const program = Effect.log("message1", "message2").pipe(
+ *   Effect.annotateLogs({ key1: "value1", key2: "value2" }),
+ *   Effect.withLogSpan("myspan")
+ * )
+ *
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.json)))
+ * // {"message":["message1","message2"],"logLevel":"INFO","timestamp":"...","annotations":{"key2":"value2","key1":"value1"},"spans":{"myspan":0},"fiberId":"#0"}
+ *
  * @since 2.0.0
  * @category constructors
  */
 export const json: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.jsonLogger)
 
 /**
+ * This logger outputs logs in a human-readable format that is easy to read
+ * during development or in a production console.
+ *
+ * @example
+ * import { Effect, Logger } from "effect"
+ *
+ * const program = Effect.log("message1", "message2").pipe(
+ *   Effect.annotateLogs({ key1: "value1", key2: "value2" }),
+ *   Effect.withLogSpan("myspan")
+ * )
+ *
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.logFmt)))
+ * // timestamp=... level=INFO fiber=#0 message=message1 message=message2 myspan=0ms key2=value2 key1=value1
+ *
  * @since 2.0.0
  * @category constructors
  */
 export const logFmt: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.logFmtLogger)
 
 /**
+ * The pretty logger utilizes the capabilities of the console API to generate
+ * visually engaging and color-enhanced log outputs. This feature is
+ * particularly useful for improving the readability of log messages during
+ * development and debugging processes.
+ *
+ * @example
+ * import { Effect, Logger } from "effect"
+ *
+ * const program = Effect.log("message1", "message2").pipe(
+ *   Effect.annotateLogs({ key1: "value1", key2: "value2" }),
+ *   Effect.withLogSpan("myspan")
+ * )
+ *
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.pretty)))
+ * //         green --v                      v-- bold and cyan
+ * // [07:51:54.434] INFO (#0) myspan=1ms: message1
+ * //   message2
+ * //    v-- bold
+ * //   key2: value2
+ * //   key1: value1
+ *
+ * @since 3.5.0
+ * @category constructors
+ */
+export const pretty: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.prettyLogger)
+
+/**
+ * The structured logger provides detailed log outputs, structured in a way that
+ * retains comprehensive traceability of the events, suitable for deeper
+ * analysis and troubleshooting.
+ *
+ * @example
+ * import { Effect, Logger } from "effect"
+ *
+ * const program = Effect.log("message1", "message2").pipe(
+ *   Effect.annotateLogs({ key1: "value1", key2: "value2" }),
+ *   Effect.withLogSpan("myspan")
+ * )
+ *
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.structured)))
+ * // {
+ * //   message: [ 'message1', 'message2' ],
+ * //   logLevel: 'INFO',
+ * //   timestamp: '2024-07-09T14:05:41.623Z',
+ * //   cause: undefined,
+ * //   annotations: { key2: 'value2', key1: 'value1' },
+ * //   spans: { myspan: 0 },
+ * //   fiberId: '#0'
+ * // }
+ *
  * @since 2.0.0
  * @category constructors
  */
 export const structured: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.structuredLogger)
 
 /**
+ * Sets the minimum log level for logging operations, allowing control over
+ * which log messages are displayed based on their severity.
+ *
+ * @example
+ * import { Effect, Logger, LogLevel } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("Executing task...")
+ *   yield* Effect.sleep("100 millis")
+ *   console.log("task done")
+ * })
+ *
+ * // Logging disabled using a layer
+ * // Effect.runFork(program.pipe(Effect.provide(Logger.minimumLogLevel(LogLevel.None))))
+ * // task done
+ *
  * @since 2.0.0
  * @category context
  */