effect 3.4.8 → 3.5.0

package/dist/esm/internal/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.4.8",
+  "version": "3.5.0",
   "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/Logger.ts

@@ -362,6 +362,19 @@ export const logfmtLogger: Logger<unknown, string> = internal.logfmtLogger
  */
 export const stringLogger: Logger<unknown, string> = internal.stringLogger
 
+/**
+ * @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
+
 /**
  * @since 2.0.0
  * @category constructors
@@ -397,6 +410,12 @@ export const json: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fibe
  */
 export const logFmt: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.logFmtLogger)
 
+/**
+ * @since 3.5.0
+ * @category constructors
+ */
+export const pretty: Layer.Layer<never> = replace(fiberRuntime.defaultLogger, fiberRuntime.prettyLogger)
+
 /**
  * @since 2.0.0
  * @category constructors

package/src/PubSub.ts

@@ -46,7 +46,9 @@ export interface PubSub<in out A> extends Queue.Enqueue<A>, Pipeable {
  * @since 2.0.0
  * @category constructors
  */
-export const bounded: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>> = internal.bounded
+export const bounded: <A>(
+  capacity: number | { readonly capacity: number; readonly replay?: number | undefined }
+) => Effect.Effect<PubSub<A>> = internal.bounded
 
 /**
  * Creates a bounded `PubSub` with the dropping strategy. The `PubSub` will drop new
@@ -57,7 +59,9 @@ export const bounded: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>>
  * @since 2.0.0
  * @category constructors
  */
-export const dropping: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>> = internal.dropping
+export const dropping: <A>(
+  capacity: number | { readonly capacity: number; readonly replay?: number | undefined }
+) => Effect.Effect<PubSub<A>> = internal.dropping
 
 /**
  * Creates a bounded `PubSub` with the sliding strategy. The `PubSub` will add new
@@ -68,7 +72,9 @@ export const dropping: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>
  * @since 2.0.0
  * @category constructors
  */
-export const sliding: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>> = internal.sliding
+export const sliding: <A>(
+  capacity: number | { readonly capacity: number; readonly replay?: number | undefined }
+) => Effect.Effect<PubSub<A>> = internal.sliding
 
 /**
  * Creates an unbounded `PubSub`.
@@ -76,7 +82,8 @@ export const sliding: <A>(requestedCapacity: number) => Effect.Effect<PubSub<A>>
  * @since 2.0.0
  * @category constructors
  */
-export const unbounded: <A>() => Effect.Effect<PubSub<A>> = internal.unbounded
+export const unbounded: <A>(options?: { readonly replay?: number | undefined }) => Effect.Effect<PubSub<A>> =
+  internal.unbounded
 
 /**
  *  Returns the number of elements the queue can hold.

package/src/Random.ts

@@ -118,3 +118,12 @@ export const randomWith: <A, E, R>(f: (random: Random) => Effect.Effect<A, E, R>
  * @category context
  */
 export const Random: Context.Tag<Random, Random> = internal.randomTag
+
+/**
+ * Constructs the `Random` service, seeding the pseudo-random number generator
+ * with an hash of the specified seed.
+ *
+ * @since 3.5.0
+ * @category constructors
+ */
+export const make: <A>(seed: A) => Random = internal.make

package/src/RcMap.ts

@@ -0,0 +1,103 @@
+/**
+ * @since 3.5.0
+ */
+import type * as Cause from "./Cause.js"
+import type * as Duration from "./Duration.js"
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/rcMap.js"
+import { type Pipeable } from "./Pipeable.js"
+import type * as Scope from "./Scope.js"
+import type * as Types from "./Types.js"
+
+/**
+ * @since 3.5.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 3.5.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 3.5.0
+ * @category models
+ */
+export interface RcMap<in K, out A, out E = never> extends Pipeable {
+  readonly [TypeId]: RcMap.Variance<K, A, E>
+}
+
+/**
+ * @since 3.5.0
+ * @category models
+ */
+export declare namespace RcMap {
+  /**
+   * @since 3.5.0
+   * @category models
+   */
+  export interface Variance<K, A, E> {
+    readonly _K: Types.Contravariant<K>
+    readonly _A: Types.Covariant<A>
+    readonly _E: Types.Covariant<E>
+  }
+}
+
+/**
+ * An `RcMap` can contain multiple reference counted resources that can be indexed
+ * by a key. The resources are lazily acquired on the first call to `get` and
+ * released when the last reference is released.
+ *
+ * Complex keys can extend `Equal` and `Hash` to allow lookups by value.
+ *
+ * @since 3.5.0
+ * @category models
+ * @param capacity The maximum number of resources that can be held in the map.
+ * @param idleTimeToLive When the reference count reaches zero, the resource will be released after this duration.
+ * @example
+ * import { Effect, RcMap } from "effect"
+ *
+ * Effect.gen(function*() {
+ *   const map = yield* RcMap.make({
+ *     lookup: (key: string) =>
+ *       Effect.acquireRelease(
+ *         Effect.succeed(`acquired ${key}`),
+ *         () => Effect.log(`releasing ${key}`)
+ *       )
+ *   })
+ *
+ *   // Get "foo" from the map twice, which will only acquire it once.
+ *   // It will then be released once the scope closes.
+ *   yield* RcMap.get(map, "foo").pipe(
+ *     Effect.andThen(RcMap.get(map, "foo")),
+ *     Effect.scoped
+ *   )
+ * })
+ */
+export const make: {
+  <K, A, E, R>(
+    options: {
+      readonly lookup: (key: K) => Effect.Effect<A, E, R>
+      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly capacity?: undefined
+    }
+  ): Effect.Effect<RcMap<K, A, E>, never, Scope.Scope | R>
+  <K, A, E, R>(
+    options: {
+      readonly lookup: (key: K) => Effect.Effect<A, E, R>
+      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly capacity: number
+    }
+  ): Effect.Effect<RcMap<K, A, E | Cause.ExceededCapacityException>, never, Scope.Scope | R>
+} = internal.make
+
+/**
+ * @since 3.5.0
+ * @category combinators
+ */
+export const get: {
+  <K>(key: K): <A, E>(self: RcMap<K, A, E>) => Effect.Effect<A, E, Scope.Scope>
+  <K, A, E>(self: RcMap<K, A, E>, key: K): Effect.Effect<A, E, Scope.Scope>
+} = internal.get

package/src/RcRef.ts

@@ -0,0 +1,91 @@
+/**
+ * @since 3.5.0
+ */
+import type * as Duration from "./Duration.js"
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/rcRef.js"
+import { type Pipeable } from "./Pipeable.js"
+import type * as Scope from "./Scope.js"
+import type * as Types from "./Types.js"
+
+/**
+ * @since 3.5.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 3.5.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 3.5.0
+ * @category models
+ */
+export interface RcRef<out A, out E = never> extends Pipeable {
+  readonly [TypeId]: RcRef.Variance<A, E>
+}
+
+/**
+ * @since 3.5.0
+ * @category models
+ */
+export declare namespace RcRef {
+  /**
+   * @since 3.5.0
+   * @category models
+   */
+  export interface Variance<A, E> {
+    readonly _A: Types.Covariant<A>
+    readonly _E: Types.Covariant<E>
+  }
+}
+
+/**
+ * Create an `RcRef` from an acquire `Effect`.
+ *
+ * An RcRef wraps a reference counted resource that can be acquired and released
+ * multiple times.
+ *
+ * The resource is lazily acquired on the first call to `get` and released when
+ * the last reference is released.
+ *
+ * @since 3.5.0
+ * @category constructors
+ * @example
+ * import { Effect, RcRef } from "effect"
+ *
+ * Effect.gen(function*() {
+ *   const ref = yield* RcRef.make({
+ *     acquire: Effect.acquireRelease(
+ *       Effect.succeed("foo"),
+ *       () => Effect.log("release foo")
+ *     )
+ *   })
+ *
+ *   // will only acquire the resource once, and release it
+ *   // when the scope is closed
+ *   yield* RcRef.get(ref).pipe(
+ *     Effect.andThen(RcRef.get(ref)),
+ *     Effect.scoped
+ *   )
+ * })
+ */
+export const make: <A, E, R>(
+  options: {
+    readonly acquire: Effect.Effect<A, E, R>
+    /**
+     * When the reference count reaches zero, the resource will be released
+     * after this duration.
+     */
+    readonly idleTimeToLive?: Duration.DurationInput | undefined
+  }
+) => Effect.Effect<RcRef<A, E>, never, R | Scope.Scope> = internal.make
+
+/**
+ * @since 3.5.0
+ * @category combinators
+ */
+export const get: <A, E>(self: RcRef<A, E>) => Effect.Effect<A, E, Scope.Scope> = internal.get