effect 3.7.2 → 3.8.0

package/src/Mailbox.ts

@@ -0,0 +1,236 @@
+/**
+ * @since 3.8.0
+ * @experimental
+ */
+import type { Cause, NoSuchElementException } from "./Cause.js"
+import type { Channel } from "./Channel.js"
+import type { Chunk } from "./Chunk.js"
+import type { Effect } from "./Effect.js"
+import type { Exit } from "./Exit.js"
+import type { Inspectable } from "./Inspectable.js"
+import * as internal from "./internal/mailbox.js"
+import type { Option } from "./Option.js"
+import { hasProperty } from "./Predicate.js"
+import type { Stream } from "./Stream.js"
+
+/**
+ * @since 3.8.0
+ * @experimental
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 3.8.0
+ * @experimental
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 3.8.0
+ * @experimental
+ * @category type ids
+ */
+export const ReadonlyTypeId: unique symbol = internal.ReadonlyTypeId
+
+/**
+ * @since 3.8.0
+ * @experimental
+ * @category type ids
+ */
+export type ReadonlyTypeId = typeof ReadonlyTypeId
+
+/**
+ * @since 3.8.0
+ * @experimental
+ * @category guards
+ */
+export const isMailbox = <A = unknown, E = unknown>(u: unknown): u is Mailbox<A, E> => hasProperty(u, TypeId)
+
+/**
+ * @since 3.8.0
+ * @experimental
+ * @category guards
+ */
+export const isReadonlyMailbox = <A = unknown, E = unknown>(u: unknown): u is ReadonlyMailbox<A, E> =>
+  hasProperty(u, ReadonlyTypeId)
+
+/**
+ * A `Mailbox` is a queue that can be signaled to be done or failed.
+ *
+ * @since 3.8.0
+ * @experimental
+ * @category models
+ */
+export interface Mailbox<in out A, in out E = never> extends ReadonlyMailbox<A, E> {
+  readonly [TypeId]: TypeId
+  /**
+   * Add a message to the mailbox. Returns `false` if the mailbox is done.
+   */
+  readonly offer: (message: A) => Effect<boolean>
+  /**
+   * Add a message to the mailbox. Returns `false` if the mailbox is done.
+   */
+  readonly unsafeOffer: (message: A) => boolean
+  /**
+   * Add multiple messages to the mailbox. Returns the remaining messages that
+   * were not added.
+   */
+  readonly offerAll: (messages: Iterable<A>) => Effect<Chunk<A>>
+  /**
+   * Add multiple messages to the mailbox. Returns the remaining messages that
+   * were not added.
+   */
+  readonly unsafeOfferAll: (messages: Iterable<A>) => Chunk<A>
+  /**
+   * Fail the mailbox with an error. If the mailbox is already done, `false` is
+   * returned.
+   */
+  readonly fail: (error: E) => Effect<boolean>
+  /**
+   * Fail the mailbox with a cause. If the mailbox is already done, `false` is
+   * returned.
+   */
+  readonly failCause: (cause: Cause<E>) => Effect<boolean>
+  /**
+   * Signal that the mailbox is complete. If the mailbox is already done, `false` is
+   * returned.
+   */
+  readonly end: Effect<boolean>
+  /**
+   * Signal that the mailbox is done. If the mailbox is already done, `false` is
+   * returned.
+   */
+  readonly done: (exit: Exit<void, E>) => Effect<boolean>
+  /**
+   * Signal that the mailbox is done. If the mailbox is already done, `false` is
+   * returned.
+   */
+  readonly unsafeDone: (exit: Exit<void, E>) => boolean
+  /**
+   * Shutdown the mailbox, canceling any pending operations.
+   * If the mailbox is already done, `false` is returned.
+   */
+  readonly shutdown: Effect<boolean>
+}
+
+/**
+ * A `ReadonlyMailbox` represents a mailbox that can only be read from.
+ *
+ * @since 3.8.0
+ * @experimental
+ * @category models
+ */
+export interface ReadonlyMailbox<out A, out E = never>
+  extends Effect<readonly [messages: Chunk<A>, done: boolean], E>, Inspectable
+{
+  readonly [ReadonlyTypeId]: ReadonlyTypeId
+  /**
+   * Take all messages from the mailbox, returning an empty Chunk if the mailbox
+   * is empty or done.
+   */
+  readonly clear: Effect<Chunk<A>, E>
+  /**
+   * Take all messages from the mailbox, or wait for messages to be available.
+   *
+   * If the mailbox is done, the `done` flag will be `true`. If the mailbox
+   * fails, the Effect will fail with the error.
+   */
+  readonly takeAll: Effect<readonly [messages: Chunk<A>, done: boolean], E>
+  /**
+   * Take a specified number of messages from the mailbox. It will only take
+   * up to the capacity of the mailbox.
+   *
+   * If the mailbox is done, the `done` flag will be `true`. If the mailbox
+   * fails, the Effect will fail with the error.
+   */
+  readonly takeN: (n: number) => Effect<readonly [messages: Chunk<A>, done: boolean], E>
+  /**
+   * Take a single message from the mailbox, or wait for a message to be
+   * available.
+   *
+   * If the mailbox is done, it will fail with `NoSuchElementException`. If the
+   * mailbox fails, the Effect will fail with the error.
+   */
+  readonly take: Effect<A, E | NoSuchElementException>
+  /** Wait for the mailbox to be done. */
+  readonly await: Effect<void, E>
+  /**
+   * Check the size of the mailbox.
+   *
+   * If the mailbox is complete, it will return `None`.
+   */
+  readonly size: Effect<Option<number>>
+  /**
+   * Check the size of the mailbox.
+   *
+   * If the mailbox is complete, it will return `None`.
+   */
+  readonly unsafeSize: () => Option<number>
+}
+
+/**
+ * A `Mailbox` is a queue that can be signaled to be done or failed.
+ *
+ * @since 3.8.0
+ * @experimental
+ * @category constructors
+ * @example
+ * import { Effect, Mailbox } from "effect"
+ *
+ * Effect.gen(function*() {
+ *   const mailbox = yield* Mailbox.make<number, string>()
+ *
+ *   // add messages to the mailbox
+ *   yield* mailbox.offer(1)
+ *   yield* mailbox.offer(2)
+ *   yield* mailbox.offerAll([3, 4, 5])
+ *
+ *   // take messages from the mailbox
+ *   const [messages, done] = yield* mailbox.takeAll
+ *   assert.deepStrictEqual(messages, [1, 2, 3, 4, 5])
+ *   assert.strictEqual(done, false)
+ *
+ *   // signal that the mailbox is done
+ *   yield* mailbox.end
+ *   const [messages2, done2] = yield* mailbox.takeAll
+ *   assert.deepStrictEqual(messages2, [])
+ *   assert.strictEqual(done2, true)
+ *
+ *   // signal that the mailbox has failed
+ *   yield* mailbox.fail("boom")
+ * })
+ */
+export const make: <A, E = never>(capacity?: number | undefined) => Effect<Mailbox<A, E>> = internal.make
+
+/**
+ * Run an `Effect` into a `Mailbox`, where success ends the mailbox and failure
+ * fails the mailbox.
+ *
+ * @since 3.8.0
+ * @experimental
+ * @category combinators
+ */
+export const into: {
+  <A, E>(self: Mailbox<A, E>): <AX, EX extends E, RX>(effect: Effect<AX, EX, RX>) => Effect<boolean, never, RX>
+  <AX, E, EX extends E, RX, A>(effect: Effect<AX, EX, RX>, self: Mailbox<A, E>): Effect<boolean, never, RX>
+} = internal.into
+
+/**
+ * Create a `Channel` from a `Mailbox`.
+ *
+ * @since 3.8.0
+ * @experimental
+ * @category conversions
+ */
+export const toChannel: <A, E>(self: ReadonlyMailbox<A, E>) => Channel<Chunk<A>, unknown, E> = internal.toChannel
+
+/**
+ * Create a `Stream` from a `Mailbox`.
+ *
+ * @since 3.8.0
+ * @experimental
+ * @category conversions
+ */
+export const toStream: <A, E>(self: ReadonlyMailbox<A, E>) => Stream<A, E> = internal.toStream

package/src/Micro.ts

@@ -2497,6 +2497,7 @@ export const ignore = <A, E, R>(self: Micro<A, E, R>): Micro<void, never, R> =>
  */
 export const ignoreLogged = <A, E, R>(self: Micro<A, E, R>): Micro<void, never, R> =>
   matchEffect(self, {
+    // eslint-disable-next-line no-console
     onFailure: (error) => sync(() => console.error(error)),
     onSuccess: (_) => void_
   })

package/src/MutableHashMap.ts

@@ -159,6 +159,18 @@ export const get: {
   return getFromBucket(self, bucket, key)
 })
 
+/**
+ * @since 3.8.0
+ * @category elements
+ */
+export const keys = <K, V>(self: MutableHashMap<K, V>): Array<K> => {
+  const keys: Array<K> = []
+  for (const [key] of self) {
+    keys.push(key)
+  }
+  return keys
+}
+
 const getFromBucket = <K, V>(
   self: MutableHashMap<K, V>,
   bucket: NonEmptyArray<readonly [K & Equal.Equal, V]>,

package/src/Number.ts

@@ -492,3 +492,26 @@ export const parse = (s: string): Option<number> => {
     ? option.none
     : option.some(n)
 }
+
+/**
+ * Returns the number rounded with the given precision.
+ *
+ * @param self - The number to round
+ * @param precision - The precision
+ *
+ * @example
+ * import { round } from "effect/Number"
+ *
+ * assert.deepStrictEqual(round(1.1234, 2), 1.12)
+ * assert.deepStrictEqual(round(1.567, 2), 1.57)
+ *
+ * @category math
+ * @since 3.8.0
+ */
+export const round: {
+  (precision: number): (self: number) => number
+  (self: number, precision: number): number
+} = dual(2, (self: number, precision: number): number => {
+  const factor = Math.pow(10, precision)
+  return Math.round(self * factor) / factor
+})

package/src/Queue.ts

@@ -10,6 +10,7 @@ import type * as MutableRef from "./MutableRef.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -74,6 +75,26 @@ export interface Queue<in out A> extends Enqueue<A>, Dequeue<A>, Pipeable {
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   /** @internal */
   readonly strategy: Strategy<A>
+
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: QueueUnify<this>
+  readonly [Unify.ignoreSymbol]?: QueueUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface QueueUnify<A extends { [Unify.typeSymbol]?: any }> extends DequeueUnify<A> {
+  Queue?: () => Extract<A[Unify.typeSymbol], Queue<any>>
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface QueueUnifyIgnore extends DequeueUnifyIgnore {
+  Dequeue?: true
 }
 
 /**
@@ -113,7 +134,7 @@ export interface Enqueue<in A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipe
  * @since 2.0.0
  * @category models
  */
-export interface Dequeue<out A> extends Queue.DequeueVariance<A>, BaseQueue, Pipeable {
+export interface Dequeue<out A> extends Effect.Effect<A>, Queue.DequeueVariance<A>, BaseQueue, Pipeable {
   /**
    * Takes the oldest value in the queue. If the queue is empty, this will return
    * a computation that resumes when an item has been added to the queue.
@@ -137,6 +158,26 @@ export interface Dequeue<out A> extends Queue.DequeueVariance<A>, BaseQueue, Pip
    * suspends until at least the minimum number of elements have been collected.
    */
   takeBetween(min: number, max: number): Effect.Effect<Chunk.Chunk<A>>
+
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: DequeueUnify<this>
+  readonly [Unify.ignoreSymbol]?: DequeueUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface DequeueUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  Dequeue?: () => A[Unify.typeSymbol] extends Dequeue<infer A0> | infer _ ? Dequeue<A0> : never
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface DequeueUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
 }
 
 /**

package/src/RcMap.ts

@@ -101,3 +101,9 @@ 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
+
+/**
+ * @since 3.8.0
+ * @category combinators
+ */
+export const keys: <K, A, E>(self: RcMap<K, A, E>) => Effect.Effect<Array<K>, E> = internal.keys

package/src/RcRef.ts

@@ -4,9 +4,10 @@
 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 Readable from "./Readable.js"
 import type * as Scope from "./Scope.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 3.5.0
@@ -24,10 +25,31 @@ export type TypeId = typeof TypeId
  * @since 3.5.0
  * @category models
  */
-export interface RcRef<out A, out E = never> extends Pipeable {
+export interface RcRef<out A, out E = never>
+  extends Effect.Effect<A, E, Scope.Scope>, Readable.Readable<A, E, Scope.Scope>
+{
   readonly [TypeId]: RcRef.Variance<A, E>
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: RcRefUnify<this>
+  readonly [Unify.ignoreSymbol]?: RcRefUnifyIgnore
 }
 
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface RcRefUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  RcRef?: () => A[Unify.typeSymbol] extends RcRef<infer A0, infer E0> | infer _ ? RcRef<A0, E0>
+    : never
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface RcRefUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
+}
 /**
  * @since 3.5.0
  * @category models

package/src/Ref.ts

@@ -4,8 +4,9 @@
 import type * as Effect from "./Effect.js"
 import * as internal from "./internal/ref.js"
 import type * as Option from "./Option.js"
-import type { Readable } from "./Readable.js"
+import type * as Readable from "./Readable.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -23,8 +24,27 @@ export type RefTypeId = typeof RefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Ref<in out A> extends Ref.Variance<A>, Readable<A> {
+export interface Ref<in out A> extends Ref.Variance<A>, Effect.Effect<A>, Readable.Readable<A> {
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B>
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: RefUnify<this>
+  readonly [Unify.ignoreSymbol]?: RefUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface RefUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  Ref?: () => Extract<A[Unify.typeSymbol], Ref<any>>
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface RefUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
 }
 
 /**

package/src/Stream.ts

@@ -549,6 +549,42 @@ export const broadcast: {
   ): Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>
 } = internal.broadcast
 
+/**
+ * Returns a new Stream that multicasts the original Stream, subscribing to it as soon as the first consumer subscribes.
+ * As long as there is at least one consumer, the upstream will continue running and emitting data.
+ * When all consumers have exited, the upstream will be finalized.
+ *
+ * @since 3.8.0
+ * @category utils
+ */
+export const share: {
+  <A, E>(
+    config: {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+      readonly idleTimeToLive?: Duration.DurationInput | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+      readonly idleTimeToLive?: Duration.DurationInput | undefined
+    }
+  ): <R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, R | Scope.Scope>
+  <A, E, R>(
+    self: Stream<A, E, R>,
+    config: {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+      readonly idleTimeToLive?: Duration.DurationInput | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+      readonly idleTimeToLive?: Duration.DurationInput | undefined
+    }
+  ): Effect.Effect<Stream<A, E>, never, R | Scope.Scope>
+} = internal.share
+
 /**
  * Fan out the stream, producing a dynamic number of streams that have the
  * same elements as this stream. The driver stream will only ever advance the

package/src/SubscriptionRef.ts

@@ -10,6 +10,7 @@ import type * as Stream from "./Stream.js"
 import type { Subscribable } from "./Subscribable.js"
 import * as Synchronized from "./SynchronizedRef.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -44,6 +45,27 @@ export interface SubscriptionRef<in out A>
    * to that value.
    */
   readonly changes: Stream.Stream<A>
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: SubscriptionRefUnify<this>
+  readonly [Unify.ignoreSymbol]?: SubscriptionRefUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface SubscriptionRefUnify<A extends { [Unify.typeSymbol]?: any }>
+  extends Synchronized.SynchronizedRefUnify<A>
+{
+  SubscriptionRef?: () => Extract<A[Unify.typeSymbol], SubscriptionRef<any>>
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface SubscriptionRefUnifyIgnore extends Synchronized.SynchronizedRefUnifyIgnore {
+  SynchronizedRef?: true
 }
 
 /**

package/src/SynchronizedRef.ts

@@ -8,6 +8,7 @@ import * as internal from "./internal/synchronizedRef.js"
 import type * as Option from "./Option.js"
 import type * as Ref from "./Ref.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -27,6 +28,25 @@ export type SynchronizedRefTypeId = typeof SynchronizedRefTypeId
  */
 export interface SynchronizedRef<in out A> extends SynchronizedRef.Variance<A>, Ref.Ref<A> {
   modifyEffect<B, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R>
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: SynchronizedRefUnify<this>
+  readonly [Unify.ignoreSymbol]?: SynchronizedRefUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface SynchronizedRefUnify<A extends { [Unify.typeSymbol]?: any }> extends Ref.RefUnify<A> {
+  SynchronizedRef?: () => Extract<A[Unify.typeSymbol], SynchronizedRef<any>>
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface SynchronizedRefUnifyIgnore extends Ref.RefUnifyIgnore {
+  Ref?: true
 }
 
 /**

package/src/TestClock.ts

@@ -304,13 +304,21 @@ export class TestClockImpl implements TestClock {
       return Option.none()
     })
   }
+
+  private yieldTimer = core.async<void>((resume) => {
+    const timer = setTimeout(() => {
+      resume(core.void)
+    }, 0)
+    return core.sync(() => clearTimeout(timer))
+  })
+
   /**
    * Returns whether all descendants of this fiber are done or suspended.
    */
   suspended(): Effect.Effect<HashMap.HashMap<FiberId.FiberId, FiberStatus.FiberStatus>, void> {
     return pipe(
       this.freeze(),
-      core.zip(this.live.provide(pipe(effect.sleep(Duration.millis(5)), core.zipRight(this.freeze())))),
+      core.zip(pipe(this.yieldTimer, core.zipRight(this.freeze()))),
       core.flatMap(([first, last]) =>
         Equal.equals(first, last) ?
           core.succeed(first) :
@@ -328,7 +336,7 @@ export class TestClockImpl implements TestClock {
         pipe(
           this.suspended(),
           core.zipWith(
-            pipe(this.live.provide(effect.sleep(Duration.millis(10))), core.zipRight(this.suspended())),
+            pipe(this.yieldTimer, core.zipRight(this.suspended())),
             Equal.equals
           ),
           effect.filterOrFail(identity, constVoid),

package/src/index.ts

@@ -409,6 +409,12 @@ export * as LogSpan from "./LogSpan.js"
  */
 export * as Logger from "./Logger.js"
 
+/**
+ * @since 3.8.0
+ * @experimental
+ */
+export * as Mailbox from "./Mailbox.js"
+
 /**
  * @since 2.0.0
  */