effect 3.9.2 → 3.10.0

package/src/Stream.ts

@@ -29,6 +29,8 @@ import type * as Sink from "./Sink.js"
 import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
+import type { TPubSub } from "./TPubSub.js"
+import type { TDequeue } from "./TQueue.js"
 import type * as Tracer from "./Tracer.js"
 import type { Covariant, NoInfer, TupleOf } from "./Types.js"
 import type * as Unify from "./Unify.js"
@@ -3322,6 +3324,14 @@ export const fromPubSub: {
   ): Stream<A>
 } = internal.fromPubSub
 
+/**
+ * Creates a stream from a subscription to a `TPubSub`.
+ *
+ * @since 3.10.0
+ * @category constructors
+ */
+export const fromTPubSub: <A>(pubsub: TPubSub<A>) => Stream<A> = internal.fromTPubSub
+
 /**
  * Creates a new `Stream` from an iterable collection of values.
  *
@@ -3403,6 +3413,14 @@ export const fromQueue: <A>(
   }
 ) => Stream<A> = internal.fromQueue
 
+/**
+ * Creates a stream from a TQueue of values
+ *
+ * @since 3.10.0
+ * @category constructors
+ */
+export const fromTQueue: <A>(queue: TDequeue<A>) => Stream<A> = internal.fromTQueue
+
 /**
  * Creates a stream from a `ReadableStream`.
  *
@@ -3411,10 +3429,32 @@ export const fromQueue: <A>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromReadableStream: <A, E>(
-  evaluate: LazyArg<ReadableStream<A>>,
-  onError: (error: unknown) => E
-) => Stream<A, E> = internal.fromReadableStream
+export const fromReadableStream: {
+  /**
+   * Creates a stream from a `ReadableStream`.
+   *
+   * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
+  <A, E>(
+    options: {
+      readonly evaluate: LazyArg<ReadableStream<A>>
+      readonly onError: (error: unknown) => E
+      readonly releaseLockOnEnd?: boolean | undefined
+    }
+  ): Stream<A, E>
+  /**
+   * Creates a stream from a `ReadableStream`.
+   *
+   * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
+  <A, E>(evaluate: LazyArg<ReadableStream<A>>, onError: (error: unknown) => E): Stream<A, E>
+} = internal.fromReadableStream
 
 /**
  * Creates a stream from a `ReadableStreamBYOBReader`.
@@ -3425,11 +3465,39 @@ export const fromReadableStream: <A, E>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromReadableStreamByob: <E>(
-  evaluate: LazyArg<ReadableStream<Uint8Array>>,
-  onError: (error: unknown) => E,
-  allocSize?: number
-) => Stream<Uint8Array, E> = internal.fromReadableStreamByob
+export const fromReadableStreamByob: {
+  /**
+   * Creates a stream from a `ReadableStreamBYOBReader`.
+   *
+   * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamBYOBReader.
+   *
+   * @param allocSize Controls the size of the underlying `ArrayBuffer` (defaults to `4096`).
+   * @since 2.0.0
+   * @category constructors
+   */
+  <E>(
+    options: {
+      readonly evaluate: LazyArg<ReadableStream<Uint8Array>>
+      readonly onError: (error: unknown) => E
+      readonly bufferSize?: number | undefined
+      readonly releaseLockOnEnd?: boolean | undefined
+    }
+  ): Stream<Uint8Array, E>
+  /**
+   * Creates a stream from a `ReadableStreamBYOBReader`.
+   *
+   * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamBYOBReader.
+   *
+   * @param allocSize Controls the size of the underlying `ArrayBuffer` (defaults to `4096`).
+   * @since 2.0.0
+   * @category constructors
+   */
+  <E>(
+    evaluate: LazyArg<ReadableStream<Uint8Array>>,
+    onError: (error: unknown) => E,
+    allocSize?: number
+  ): Stream<Uint8Array, E>
+} = internal.fromReadableStreamByob
 
 /**
  * Creates a stream from a `Schedule` that does not require any further

package/src/TPubSub.ts

@@ -107,6 +107,15 @@ export const isEmpty: <A>(self: TPubSub<A>) => STM.STM<boolean> = internal.isEmp
  */
 export const isFull: <A>(self: TPubSub<A>) => STM.STM<boolean> = internal.isFull
 
+/**
+ * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
+ * to `offer*` and `take*` will be interrupted immediately.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const shutdown: <A>(self: TPubSub<A>) => STM.STM<void> = internal.shutdown
+
 /**
  * Returns `true` if `shutdown` has been called, otherwise returns `false`.
  *

package/src/TQueue.ts

@@ -206,7 +206,7 @@ export const isTEnqueue: (u: unknown) => u is TEnqueue<unknown> = internal.isTEn
  * @since 2.0.0
  * @category mutations
  */
-export const awaitShutdown: <A>(self: TQueue<A>) => STM.STM<void> = internal.awaitShutdown
+export const awaitShutdown: <A>(self: TDequeue<A> | TEnqueue<A>) => STM.STM<void> = internal.awaitShutdown
 
 /**
  * Creates a bounded queue with the back pressure strategy. The queue will
@@ -226,7 +226,7 @@ export const bounded: <A>(requestedCapacity: number) => STM.STM<TQueue<A>> = int
  * @since 2.0.0
  * @category getters
  */
-export const capacity: <A>(self: TQueue<A>) => number = internal.capacity
+export const capacity: <A>(self: TDequeue<A> | TEnqueue<A>) => number = internal.capacity
 
 /**
  * Creates a bounded queue with the dropping strategy. The queue will drop new
@@ -245,7 +245,7 @@ export const dropping: <A>(requestedCapacity: number) => STM.STM<TQueue<A>> = in
  * @since 2.0.0
  * @category getters
  */
-export const isEmpty: <A>(self: TQueue<A>) => STM.STM<boolean> = internal.isEmpty
+export const isEmpty: <A>(self: TDequeue<A> | TEnqueue<A>) => STM.STM<boolean> = internal.isEmpty
 
 /**
  * Returns `true` if the `TQueue` contains at least one element, `false`
@@ -254,7 +254,7 @@ export const isEmpty: <A>(self: TQueue<A>) => STM.STM<boolean> = internal.isEmpt
  * @since 2.0.0
  * @category getters
  */
-export const isFull: <A>(self: TQueue<A>) => STM.STM<boolean> = internal.isFull
+export const isFull: <A>(self: TDequeue<A> | TEnqueue<A>) => STM.STM<boolean> = internal.isFull
 
 /**
  * Returns `true` if `shutdown` has been called, otherwise returns `false`.
@@ -262,7 +262,7 @@ export const isFull: <A>(self: TQueue<A>) => STM.STM<boolean> = internal.isFull
  * @since 2.0.0
  * @category getters
  */
-export const isShutdown: <A>(self: TQueue<A>) => STM.STM<boolean> = internal.isShutdown
+export const isShutdown: <A>(self: TDequeue<A> | TEnqueue<A>) => STM.STM<boolean> = internal.isShutdown
 
 /**
  * Places one value in the queue.
@@ -409,7 +409,7 @@ export const seek: {
  * @since 2.0.0
  * @category mutations
  */
-export const shutdown: <A>(self: TQueue<A>) => STM.STM<void> = internal.shutdown
+export const shutdown: <A>(self: TDequeue<A> | TEnqueue<A>) => STM.STM<void> = internal.shutdown
 
 /**
  * Retrieves the size of the queue, which is equal to the number of elements
@@ -419,7 +419,7 @@ export const shutdown: <A>(self: TQueue<A>) => STM.STM<void> = internal.shutdown
  * @since 2.0.0
  * @category getters
  */
-export const size: <A>(self: TQueue<A>) => STM.STM<number> = internal.size
+export const size: <A>(self: TDequeue<A> | TEnqueue<A>) => STM.STM<number> = internal.size
 
 /**
  * Creates a bounded queue with the sliding strategy. The queue will add new

package/src/TRef.ts

@@ -7,6 +7,7 @@ import type * as TxnId from "./internal/stm/stm/txnId.js"
 import type * as Versioned from "./internal/stm/stm/versioned.js"
 import * as internal from "./internal/stm/tRef.js"
 import type * as Option from "./Option.js"
+import type { Pipeable } from "./Pipeable.js"
 import type * as STM from "./STM.js"
 import type * as Types from "./Types.js"
 
@@ -34,7 +35,7 @@ export type TRefTypeId = typeof TRefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TRef<in out A> extends TRef.Variance<A> {
+export interface TRef<in out A> extends TRef.Variance<A>, Pipeable {
   /**
    * Note: the method is unbound, exposed only for potential extensions.
    */

package/src/TSubscriptionRef.ts

@@ -0,0 +1,284 @@
+/**
+ * @since 3.10.0
+ */
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/stm/tSubscriptionRef.js"
+import type * as Option from "./Option.js"
+import type * as Scope from "./Scope.js"
+import type * as STM from "./STM.js"
+import type * as Stream from "./Stream.js"
+import type * as TPubSub from "./TPubSub.js"
+import type * as TQueue from "./TQueue.js"
+import type * as TRef from "./TRef.js"
+import type * as Types from "./Types.js"
+
+/**
+ * @since 3.10.0
+ * @category symbols
+ */
+export const TSubscriptionRefTypeId: unique symbol = internal.TSubscriptionRefTypeId
+
+/**
+ * @since 3.10.0
+ * @category symbols
+ */
+export type TSubscriptionRefTypeId = typeof TSubscriptionRefTypeId
+
+/**
+ * A `TSubscriptionRef<A>` is a `TRef` that can be subscribed to in order to
+ * receive a `TDequeue<A>` of the current value and all committed changes to the value.
+ *
+ * @since 3.10.0
+ * @category models
+ */
+export interface TSubscriptionRef<in out A> extends TSubscriptionRef.Variance<A>, TRef.TRef<A> {
+  /** @internal */
+  readonly ref: TRef.TRef<A>
+  /** @internal */
+  readonly pubsub: TPubSub.TPubSub<A>
+  /** @internal */
+  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<B>
+
+  /**
+   * A TDequeue containing the current value of the `Ref` as well as all changes
+   * to that value.
+   */
+  readonly changes: STM.STM<TQueue.TDequeue<A>>
+}
+
+/**
+ * @since 3.10.0
+ */
+export declare namespace TSubscriptionRef {
+  /**
+   * @since 3.10.0
+   * @category models
+   */
+  export interface Variance<in out A> {
+    readonly [TSubscriptionRefTypeId]: {
+      readonly _A: Types.Invariant<A>
+    }
+  }
+}
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const get: <A>(self: TSubscriptionRef<A>) => STM.STM<A> = internal.get
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const getAndSet: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(value: A): (self: TSubscriptionRef<A>) => STM.STM<A>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, value: A): STM.STM<A>
+} = internal.getAndSet
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const getAndUpdate: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(f: (a: A) => A): (self: TSubscriptionRef<A>) => STM.STM<A>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, f: (a: A) => A): STM.STM<A>
+} = internal.getAndUpdate
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const getAndUpdateSome: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(f: (a: A) => Option.Option<A>): (self: TSubscriptionRef<A>) => STM.STM<A>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, f: (a: A) => Option.Option<A>): STM.STM<A>
+} = internal.getAndUpdateSome
+
+/**
+ * @since 3.10.0
+ * @category constructors
+ */
+export const make: <A>(value: A) => STM.STM<TSubscriptionRef<A>> = internal.make
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const modify: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A, B>(f: (a: A) => readonly [B, A]): (self: TSubscriptionRef<A>) => STM.STM<B>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A, B>(self: TSubscriptionRef<A>, f: (a: A) => readonly [B, A]): STM.STM<B>
+} = internal.modify
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const modifySome: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A, B>(fallback: B, f: (a: A) => Option.Option<readonly [B, A]>): (self: TSubscriptionRef<A>) => STM.STM<B>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A, B>(
+    self: TSubscriptionRef<A>,
+    fallback: B,
+    f: (a: A) => Option.Option<readonly [B, A]>
+  ): STM.STM<B>
+} = internal.modifySome
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const set: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(value: A): (self: TSubscriptionRef<A>) => STM.STM<void>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, value: A): STM.STM<void>
+} = internal.set
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const setAndGet: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(value: A): (self: TSubscriptionRef<A>) => STM.STM<A>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, value: A): STM.STM<A>
+} = internal.setAndGet
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const update: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(f: (a: A) => A): (self: TSubscriptionRef<A>) => STM.STM<void>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, f: (a: A) => A): STM.STM<void>
+} = internal.update
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const updateAndGet: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(f: (a: A) => A): (self: TSubscriptionRef<A>) => STM.STM<A>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, f: (a: A) => A): STM.STM<A>
+} = internal.updateAndGet
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const updateSome: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(f: (a: A) => Option.Option<A>): (self: TSubscriptionRef<A>) => STM.STM<void>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, f: (a: A) => Option.Option<A>): STM.STM<void>
+} = internal.updateSome
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const updateSomeAndGet: {
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(f: (a: A) => Option.Option<A>): (self: TSubscriptionRef<A>) => STM.STM<A>
+  /**
+   * @since 3.10.0
+   * @category mutations
+   */
+  <A>(self: TSubscriptionRef<A>, f: (a: A) => Option.Option<A>): STM.STM<A>
+} = internal.updateSomeAndGet
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const changesScoped: <A>(self: TSubscriptionRef<A>) => Effect.Effect<TQueue.TDequeue<A>, never, Scope.Scope> =
+  internal.changesScoped
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const changesStream: <A>(self: TSubscriptionRef<A>) => Stream.Stream<A> = internal.changesStream
+
+/**
+ * @since 3.10.0
+ * @category mutations
+ */
+export const changes: <A>(self: TSubscriptionRef<A>) => STM.STM<TQueue.TDequeue<A>> = (self) => self.changes

package/src/index.ts

@@ -29,6 +29,11 @@ export {
   unsafeCoerce
 } from "./Function.js"
 
+/**
+ * @since 3.10.0
+ */
+export * as Arbitrary from "./Arbitrary.js"
+
 /**
  * This module provides utility functions for working with arrays in TypeScript.
  *
@@ -262,6 +267,11 @@ export * as ExecutionStrategy from "./ExecutionStrategy.js"
  */
 export * as Exit from "./Exit.js"
 
+/**
+ * @since 3.10.0
+ */
+export * as FastCheck from "./FastCheck.js"
+
 /**
  * @since 2.0.0
  */
@@ -354,6 +364,11 @@ export * as Inspectable from "./Inspectable.js"
  */
 export * as Iterable from "./Iterable.js"
 
+/**
+ * @since 3.10.0
+ */
+export * as JSONSchema from "./JSONSchema.js"
+
 /**
  * @since 2.0.0
  */
@@ -574,6 +589,11 @@ export * as Order from "./Order.js"
  */
 export * as Ordering from "./Ordering.js"
 
+/**
+ * @since 3.10.0
+ */
+export * as ParseResult from "./ParseResult.js"
+
 /**
  * @since 2.0.0
  */
@@ -589,6 +609,11 @@ export * as Pool from "./Pool.js"
  */
 export * as Predicate from "./Predicate.js"
 
+/**
+ * @since 3.10.0
+ */
+export * as Pretty from "./Pretty.js"
+
 /**
  * @since 2.0.0
  */
@@ -735,6 +760,16 @@ export * as ScheduleIntervals from "./ScheduleIntervals.js"
  */
 export * as Scheduler from "./Scheduler.js"
 
+/**
+ * @since 3.10.0
+ */
+export * as Schema from "./Schema.js"
+
+/**
+ * @since 3.10.0
+ */
+export * as SchemaAST from "./SchemaAST.js"
+
 /**
  * @since 2.0.0
  */
@@ -895,6 +930,11 @@ export * as TSemaphore from "./TSemaphore.js"
  */
 export * as TSet from "./TSet.js"
 
+/**
+ * @since 3.10.0
+ */
+export * as TSubscriptionRef from "./TSubscriptionRef.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/cause.ts

@@ -8,7 +8,7 @@ import { constFalse, constTrue, dual, identity, pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashSet from "../HashSet.js"
-import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { NodeInspectSymbol, stringifyCircular, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
@@ -1042,7 +1042,7 @@ class PrettyError extends globalThis.Error implements Cause.PrettyError {
  * 1) If the input `u` is already a string, it's considered a message.
  * 2) If `u` is an Error instance with a message defined, it uses the message.
  * 3) If `u` has a user-defined `toString()` method, it uses that method.
- * 4) Otherwise, it uses `JSON.stringify` to produce a string representation and uses it as the error message,
+ * 4) Otherwise, it uses `Inspectable.stringifyCircular` to produce a string representation and uses it as the error message,
  *   with "Error" added as a prefix.
  *
  * @internal
@@ -1070,7 +1070,7 @@ export const prettyErrorMessage = (u: unknown): string => {
     // something's off, rollback to json
   }
   // 4)
-  return JSON.stringify(u)
+  return stringifyCircular(u)
 }
 
 const locationRegex = /\((.*)\)/

package/src/internal/core-effect.ts

@@ -85,7 +85,7 @@ export const try_: {
     readonly try: LazyArg<A>
     readonly catch: (error: unknown) => E
   }): Effect.Effect<A, E>
-  <A>(evaluate: LazyArg<A>): Effect.Effect<A, Cause.UnknownException>
+  <A>(thunk: LazyArg<A>): Effect.Effect<A, Cause.UnknownException>
 } = <A, E>(
   arg: LazyArg<A> | {
     readonly try: LazyArg<A>
@@ -1656,7 +1656,7 @@ export const tryPromise: {
       readonly catch: (error: unknown) => E
     }
   ): Effect.Effect<A, E>
-  <A>(try_: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, Cause.UnknownException>
+  <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, Cause.UnknownException>
 } = <A, E>(
   arg: ((signal: AbortSignal) => PromiseLike<A>) | {
     readonly try: (signal: AbortSignal) => PromiseLike<A>

package/src/internal/core.ts

@@ -521,13 +521,13 @@ export const unsafeAsync = <A, E = never, R = never>(
 
 /* @internal */
 export const async = <A, E = never, R = never>(
-  register: (
+  resume: (
     callback: (_: Effect.Effect<A, E, R>) => void,
     signal: AbortSignal
   ) => void | Effect.Effect<void, never, R>,
   blockingOn: FiberId.FiberId = FiberId.none
 ): Effect.Effect<A, E, R> => {
-  return custom(register, function() {
+  return custom(resume, function() {
     let backingResume: ((_: Effect.Effect<A, E, R>) => void) | undefined = undefined
     let pendingEffect: Effect.Effect<A, E, R> | undefined = undefined
     function proxyResume(effect: Effect.Effect<A, E, R>) {
@@ -1216,9 +1216,9 @@ export const suspend = <A, E, R>(effect: LazyArg<Effect.Effect<A, E, R>>): Effec
   flatMap(sync(effect), identity)
 
 /* @internal */
-export const sync = <A>(evaluate: LazyArg<A>): Effect.Effect<A> => {
+export const sync = <A>(thunk: LazyArg<A>): Effect.Effect<A> => {
   const effect = new EffectPrimitive(OpCodes.OP_SYNC) as any
-  effect.effect_instruction_i0 = evaluate
+  effect.effect_instruction_i0 = thunk
   return effect
 }
 

package/src/internal/fiberRuntime.ts

@@ -827,18 +827,20 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
     if (HashSet.size(loggers) > 0) {
       const clockService = Context.get(this.getFiberRef(defaultServices.currentServices), clock.clockTag)
       const date = new Date(clockService.unsafeCurrentTimeMillis())
-      for (const logger of loggers) {
-        logger.log({
-          fiberId: this.id(),
-          logLevel,
-          message,
-          cause,
-          context: contextMap,
-          spans,
-          annotations,
-          date
-        })
-      }
+      Inspectable.withRedactableContext(contextMap, () => {
+        for (const logger of loggers) {
+          logger.log({
+            fiberId: this.id(),
+            logLevel,
+            message,
+            cause,
+            context: contextMap,
+            spans,
+            annotations,
+            date
+          })
+        }
+      })
     }
   }