effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/String.ts

@@ -13,6 +13,7 @@ import type { NonEmptyArray } from "./Array.ts"
 import * as Equ from "./Equivalence.ts"
 import { dual } from "./Function.ts"
 import * as readonlyArray from "./internal/array.ts"
+import * as Count from "./internal/count.ts"
 import * as number from "./Number.ts"
 import * as Option from "./Option.ts"
 import * as order from "./Order.ts"
@@ -956,6 +957,10 @@ export const padStart = (maxLength: number, fillString?: string) => (self: strin
 /**
  * Repeats the string the specified number of times.
  *
+ * **Details**
+ *
+ * `count` is rounded down. `NaN` and non-positive values are treated as `0`.
+ *
  * **Example** (Repeating strings)
  *
  * ```ts import.meta.vitest
@@ -968,7 +973,7 @@ export const padStart = (maxLength: number, fillString?: string) => (self: strin
  * @category transforming
  * @since 2.0.0
  */
-export const repeat = (count: number) => (self: string): string => self.repeat(count)
+export const repeat = (count: number) => (self: string): string => self.repeat(Count.normalize(count))
 
 /**
  * Replaces all occurrences of a substring or pattern in a string.
@@ -1092,7 +1097,8 @@ export const toLocaleUpperCase = (locale?: string | Array<string>) => (self: str
  * If `n` is larger than the available number of characters, the string will
  * be returned whole.
  *
- * If `n` is not a positive number, an empty string will be returned.
+ * If `n` is not a positive number, including `NaN`, an empty string will be
+ * returned.
  *
  * If `n` is a float, it will be rounded down to the nearest integer.
  *
@@ -1116,7 +1122,8 @@ export const takeLeft: {
    * If `n` is larger than the available number of characters, the string will
    * be returned whole.
    *
-   * If `n` is not a positive number, an empty string will be returned.
+   * If `n` is not a positive number, including `NaN`, an empty string will be
+   * returned.
    *
    * If `n` is a float, it will be rounded down to the nearest integer.
    *
@@ -1140,7 +1147,8 @@ export const takeLeft: {
    * If `n` is larger than the available number of characters, the string will
    * be returned whole.
    *
-   * If `n` is not a positive number, an empty string will be returned.
+   * If `n` is not a positive number, including `NaN`, an empty string will be
+   * returned.
    *
    * If `n` is a float, it will be rounded down to the nearest integer.
    *
@@ -1156,7 +1164,7 @@ export const takeLeft: {
    * @since 2.0.0
    */
   (self: string, n: number): string
-} = dual(2, (self: string, n: number): string => self.slice(0, Math.max(n, 0)))
+} = dual(2, (self: string, n: number): string => self.slice(0, Count.normalize(n)))
 
 /**
  * Keeps the specified number of characters from the end of a string.
@@ -1166,7 +1174,8 @@ export const takeLeft: {
  * If `n` is larger than the available number of characters, the string will
  * be returned whole.
  *
- * If `n` is not a positive number, an empty string will be returned.
+ * If `n` is not a positive number, including `NaN`, an empty string will be
+ * returned.
  *
  * If `n` is a float, it will be rounded down to the nearest integer.
  *
@@ -1190,7 +1199,8 @@ export const takeRight: {
    * If `n` is larger than the available number of characters, the string will
    * be returned whole.
    *
-   * If `n` is not a positive number, an empty string will be returned.
+   * If `n` is not a positive number, including `NaN`, an empty string will be
+   * returned.
    *
    * If `n` is a float, it will be rounded down to the nearest integer.
    *
@@ -1214,7 +1224,8 @@ export const takeRight: {
    * If `n` is larger than the available number of characters, the string will
    * be returned whole.
    *
-   * If `n` is not a positive number, an empty string will be returned.
+   * If `n` is not a positive number, including `NaN`, an empty string will be
+   * returned.
    *
    * If `n` is a float, it will be rounded down to the nearest integer.
    *
@@ -1232,7 +1243,7 @@ export const takeRight: {
   (self: string, n: number): string
 } = dual(
   2,
-  (self: string, n: number): string => self.slice(Math.max(0, self.length - Math.floor(n)), Infinity)
+  (self: string, n: number): string => self.slice(self.length - Math.min(Count.normalize(n), self.length), Infinity)
 )
 
 const CR = 0x0d

package/src/Struct.ts

@@ -305,7 +305,7 @@ export const pick: {
 } = dual(
   2,
   <S extends object, const Keys extends ReadonlyArray<keyof S>>(self: S, keys: Keys) => {
-    return buildStruct(self, (k, v) => (keys.includes(k) ? [k, v] : undefined))
+    return buildStruct(self, (k, v) => (hasPropertyKey(keys, k) ? [k, v] : undefined))
   }
 )
 
@@ -387,7 +387,7 @@ export const omit: {
 } = dual(
   2,
   <S extends object, Keys extends ReadonlyArray<keyof S>>(self: S, keys: Keys) => {
-    return buildStruct(self, (k, v) => (!keys.includes(k) ? [k, v] : undefined))
+    return buildStruct(self, (k, v) => (!hasPropertyKey(keys, k) ? [k, v] : undefined))
   }
 )
 
@@ -1327,7 +1327,7 @@ export const mapPick: {
     keys: Keys,
     lambda: L
   ) => {
-    return buildStruct(self, (k, v) => [k, keys.includes(k) ? lambda(v) : v])
+    return buildStruct(self, (k, v) => [k, hasPropertyKey(keys, k) ? lambda(v) : v])
   }
 )
 
@@ -1436,10 +1436,14 @@ export const mapOmit: {
     keys: Keys,
     lambda: L
   ) => {
-    return buildStruct(self, (k, v) => [k, !keys.includes(k) ? lambda(v) : v])
+    return buildStruct(self, (k, v) => [k, !hasPropertyKey(keys, k) ? lambda(v) : v])
   }
 )
 
+function hasPropertyKey(keys: ReadonlyArray<PropertyKey>, key: PropertyKey): boolean {
+  return keys.some((candidate) => candidate === key || typeof candidate === "number" && String(candidate) === key)
+}
+
 /**
  * Walk `source`; for each key decide what to emit via the small callback.
  *

package/src/SynchronizedRef.ts

@@ -14,6 +14,7 @@ import * as Effect from "./Effect.ts"
 import { dual } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
+import type { Pipeable } from "./Pipeable.ts"
 import * as Ref from "./Ref.ts"
 import * as Semaphore from "./Semaphore.ts"
 
@@ -34,7 +35,7 @@ const TypeId = "~effect/SynchronizedRef"
  * @category models
  * @since 2.0.0
  */
-export interface SynchronizedRef<in out A> extends Ref.Ref<A> {
+export interface SynchronizedRef<in out A> extends Pipeable {
   readonly [TypeId]: typeof TypeId
   readonly backing: Ref.Ref<A>
   readonly semaphore: Semaphore.Semaphore
@@ -639,10 +640,7 @@ export const modifySomeEffect: {
    * @category mutations
    * @since 2.0.0
    */
-  <A, B, R, E>(
-    fallback: B,
-    pf: (a: A) => Effect.Effect<readonly [B, Option.Option<A>], E, R>
-  ): (self: SynchronizedRef<A>) => Effect.Effect<B, E, R>
+  <A, B, R, E>(pf: (a: A) => Effect.Effect<readonly [B, Option.Option<A>], E, R>): (self: SynchronizedRef<A>) => Effect.Effect<B, E, R>
   /**
    * Runs an effectful modification atomically while holding the ref's semaphore.
    * The effect computes a return value and an optional new ref value;

package/src/Terminal.ts

@@ -19,7 +19,7 @@ import type * as Queue from "./Queue.ts"
 import * as Schema from "./Schema.ts"
 import type * as Scope from "./Scope.ts"
 
-const TypeId = "~effect/platform/Terminal"
+const TypeId = "~effect/Terminal"
 
 /**
  * A `Terminal` represents a command-line interface which can read input from a
@@ -105,7 +105,7 @@ export interface UserInput {
   readonly key: Key
 }
 
-const QuitErrorTypeId = "effect/platform/Terminal/QuitError"
+const QuitErrorTypeId = "~effect/Terminal/QuitError"
 
 /**
  * Represents an error that occurs when a user attempts to
@@ -163,7 +163,7 @@ export const isQuitError = (u: unknown): u is QuitError => Predicate.hasProperty
  * @category services
  * @since 4.0.0
  */
-export const Terminal: Context.Service<Terminal, Terminal> = Context.Service("effect/platform/Terminal")
+export const Terminal: Context.Service<Terminal, Terminal> = Context.Service("effect/Terminal")
 
 /**
  * Creates a `Terminal` service implementation.

package/src/Tracer.ts

@@ -631,10 +631,24 @@ export const TracerKey = "effect/Tracer"
  */
 export const Tracer: Context.Reference<Tracer> = Context.Reference<Tracer>(TracerKey, {
   fiberCached: true,
-  defaultValue: () =>
-    make({
-      span: (options) => new NativeSpan(options)
-    })
+  defaultValue: () => nativeTracer
+})
+
+/**
+ * The default `Tracer` implementation backing the `Tracer` reference. It
+ * creates in-memory `NativeSpan` instances and does not export them anywhere.
+ *
+ * **Details**
+ *
+ * Runtime code can compare the active tracer against `nativeTracer` to detect
+ * that no tracing backend is installed and skip work that only a backend could
+ * observe, such as recording span attributes.
+ *
+ * @category references
+ * @since 4.0.0
+ */
+export const nativeTracer: Tracer = make({
+  span: (options) => new NativeSpan(options)
 })
 
 /**
@@ -644,9 +658,11 @@ export const Tracer: Context.Reference<Tracer> = Context.Reference<Tracer>(Trace
  *
  * **Details**
  *
- * The constructor initializes the span with `Started` status, inherits the
- * parent trace id or generates a new one, and always generates a new span id.
- * Attributes, events, links, and status are then mutated through `Span` methods.
+ * The constructor initializes the span with `Started` status. Trace and span
+ * identifiers, the attribute map, and the event list are created lazily on
+ * first access, so spans that are never inspected allocate as little as
+ * possible. Attributes, events, links, and status are mutated through `Span`
+ * methods.
  *
  * @see {@link Span} for the interface implemented by native spans
  *
@@ -655,8 +671,6 @@ export const Tracer: Context.Reference<Tracer> = Context.Reference<Tracer>(Trace
  */
 export class NativeSpan implements Span {
   readonly _tag = "Span"
-  readonly spanId: string
-  readonly traceId: string = "native"
   readonly sampled: boolean
 
   readonly name: string
@@ -667,8 +681,10 @@ export class NativeSpan implements Span {
   readonly kind: SpanKind
 
   status: SpanStatus
-  attributes: Map<string, unknown>
-  events: Array<[name: string, startTime: bigint, attributes: Record<string, unknown>]> = []
+  _traceId: string | undefined = undefined
+  _spanId: string | undefined = undefined
+  _attributes: Map<string, unknown> | undefined = undefined
+  _events: Array<[name: string, startTime: bigint, attributes: Record<string, unknown>]> | undefined = undefined
 
   constructor(options: {
     readonly name: string
@@ -690,9 +706,22 @@ export class NativeSpan implements Span {
       _tag: "Started",
       startTime: options.startTime
     }
-    this.attributes = new Map()
-    this.traceId = Option.getOrUndefined(options.parent)?.traceId ?? Encoding.randomHex(32)
-    this.spanId = Encoding.randomHex(16)
+  }
+
+  get traceId(): string {
+    return this._traceId ??= Option.getOrUndefined(this.parent)?.traceId ?? Encoding.randomHex(32)
+  }
+
+  get spanId(): string {
+    return this._spanId ??= Encoding.randomHex(16)
+  }
+
+  get attributes(): Map<string, unknown> {
+    return this._attributes ??= new Map()
+  }
+
+  get events(): Array<[name: string, startTime: bigint, attributes: Record<string, unknown>]> {
+    return this._events ??= []
   }
 
   end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void {

package/src/Tuple.ts

@@ -475,7 +475,9 @@ export const appendElements: {
 
 type Evolver<T> = { readonly [I in keyof T]?: ((a: T[I]) => unknown) | undefined }
 
-type Evolved<T, E> = { [I in keyof T]: I extends keyof E ? (E[I] extends (...a: any) => infer R ? R : T[I]) : T[I] }
+type EvolveElement<A, F> = F extends (...a: any) => infer R ? R : A
+
+type Evolved<T, E> = { [I in keyof T]: I extends keyof E ? EvolveElement<T[I], E[I]> : T[I] }
 
 /**
  * Transforms elements of a tuple by providing an array of transform functions.

package/src/TxChunk.ts

@@ -21,7 +21,7 @@ import { pipeArguments } from "./Pipeable.ts"
 import * as TxRef from "./TxRef.ts"
 import type { NoInfer } from "./Types.ts"
 
-const TypeId = "~effect/transactions/TxChunk"
+const TypeId = "~effect/TxChunk"
 
 /**
  * TxChunk is a transactional chunk data structure that provides Software Transactional Memory (STM)

package/src/TxDeferred.ts

@@ -23,7 +23,7 @@ import type { Result } from "./Result.ts"
 import * as Res from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
 
-const TypeId = "~effect/transactions/TxDeferred"
+const TypeId = "~effect/TxDeferred"
 
 /**
  * A transactional deferred is a write-once cell readable within transactions.

package/src/TxHashMap.ts

@@ -23,7 +23,7 @@ import { hasProperty } from "./Predicate.ts"
 import type { Result } from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
 
-const TypeId = "~effect/transactions/TxHashMap"
+const TypeId = "~effect/TxHashMap"
 
 const TxHashMapProto = {
   [TypeId]: TypeId,

package/src/TxHashSet.ts

@@ -25,7 +25,7 @@ import { hasProperty, type Predicate, type Refinement } from "./Predicate.ts"
 import * as TxRef from "./TxRef.ts"
 import type { NoInfer } from "./Types.ts"
 
-const TypeId = "~effect/transactions/TxHashSet"
+const TypeId = "~effect/TxHashSet"
 
 const TxHashSetProto = {
   [TypeId]: TypeId,
@@ -1990,12 +1990,52 @@ export const filter: {
    * @since 4.0.0
    */
   {
-    <V, U extends V>(
-      refinement: Refinement<NoInfer<V>, U>
-    ): (self: TxHashSet<V>) => Effect.Effect<TxHashSet<U>>;
-    <V>(
-      predicate: Predicate<NoInfer<V>>
-    ): (self: TxHashSet<V>) => Effect.Effect<TxHashSet<V>>;
+    /**
+     * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
+     *
+     * **Example** (Filtering values)
+     *
+     * ```ts import.meta.vitest
+     * import { Effect, TxHashSet } from "effect"
+     *
+     * const program = Effect.gen(function*() {
+     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
+     *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
+     *
+     *   Array.from(yield* TxHashSet.toHashSet(evens)).sort() // => [2, 4, 6]
+     *   yield* TxHashSet.size(evens) // => 3
+     * })
+     *
+     * await Effect.runPromise(program)
+     * ```
+     *
+     * @category filtering
+     * @since 4.0.0
+     */
+    <V, U extends V>(refinement: Refinement<NoInfer<V>, U>): (self: TxHashSet<V>) => Effect.Effect<TxHashSet<U>>;
+    /**
+     * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
+     *
+     * **Example** (Filtering values)
+     *
+     * ```ts import.meta.vitest
+     * import { Effect, TxHashSet } from "effect"
+     *
+     * const program = Effect.gen(function*() {
+     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
+     *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
+     *
+     *   Array.from(yield* TxHashSet.toHashSet(evens)).sort() // => [2, 4, 6]
+     *   yield* TxHashSet.size(evens) // => 3
+     * })
+     *
+     * await Effect.runPromise(program)
+     * ```
+     *
+     * @category filtering
+     * @since 4.0.0
+     */
+    <V>(predicate: Predicate<NoInfer<V>>): (self: TxHashSet<V>) => Effect.Effect<TxHashSet<V>>;
   },
   /**
    * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
@@ -2020,10 +2060,51 @@ export const filter: {
    * @since 4.0.0
    */
   {
-    <V, U extends V>(
-      self: TxHashSet<V>,
-      refinement: Refinement<V, U>
-    ): Effect.Effect<TxHashSet<U>>;
+    /**
+     * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
+     *
+     * **Example** (Filtering values)
+     *
+     * ```ts import.meta.vitest
+     * import { Effect, TxHashSet } from "effect"
+     *
+     * const program = Effect.gen(function*() {
+     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
+     *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
+     *
+     *   Array.from(yield* TxHashSet.toHashSet(evens)).sort() // => [2, 4, 6]
+     *   yield* TxHashSet.size(evens) // => 3
+     * })
+     *
+     * await Effect.runPromise(program)
+     * ```
+     *
+     * @category filtering
+     * @since 4.0.0
+     */
+    <V, U extends V>(self: TxHashSet<V>, refinement: Refinement<V, U>): Effect.Effect<TxHashSet<U>>;
+    /**
+     * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
+     *
+     * **Example** (Filtering values)
+     *
+     * ```ts import.meta.vitest
+     * import { Effect, TxHashSet } from "effect"
+     *
+     * const program = Effect.gen(function*() {
+     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
+     *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
+     *
+     *   Array.from(yield* TxHashSet.toHashSet(evens)).sort() // => [2, 4, 6]
+     *   yield* TxHashSet.size(evens) // => 3
+     * })
+     *
+     * await Effect.runPromise(program)
+     * ```
+     *
+     * @category filtering
+     * @since 4.0.0
+     */
     <V>(self: TxHashSet<V>, predicate: Predicate<V>): Effect.Effect<TxHashSet<V>>;
   }
 >(2, <V>(self: TxHashSet<V>, predicate: Predicate<V>) =>

package/src/TxPriorityQueue.ts

@@ -26,7 +26,7 @@ import { pipeArguments } from "./Pipeable.ts"
 import { hasProperty, type Predicate } from "./Predicate.ts"
 import * as TxRef from "./TxRef.ts"
 
-const TypeId = "~effect/transactions/TxPriorityQueue"
+const TypeId = "~effect/TxPriorityQueue"
 
 /**
  * A transactional priority queue backed by a sorted `Chunk`.

package/src/TxPubSub.ts

@@ -21,7 +21,7 @@ import type * as Scope from "./Scope.ts"
 import * as TxQueue from "./TxQueue.ts"
 import * as TxRef from "./TxRef.ts"
 
-const TypeId = "~effect/transactions/TxPubSub"
+const TypeId = "~effect/TxPubSub"
 
 /**
  * A TxPubSub represents a transactional publish/subscribe hub that broadcasts messages

package/src/TxQueue.ts

@@ -17,6 +17,7 @@ import * as Effect from "./Effect.ts"
 import { dual } from "./Function.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
+import * as Count from "./internal/count.ts"
 import * as Option from "./Option.ts"
 import { hasProperty } from "./Predicate.ts"
 import { type ExcludeDone, isDoneCause } from "./Pull.ts"
@@ -59,9 +60,9 @@ export type State<_A, E> =
     readonly cause: Cause.Cause<E>
   }
 
-const EnqueueTypeId = "~effect/transactions/TxQueue/Enqueue"
-const DequeueTypeId = "~effect/transactions/TxQueue/Dequeue"
-const TypeId = "~effect/transactions/TxQueue"
+const EnqueueTypeId = "~effect/TxQueue/Enqueue"
+const DequeueTypeId = "~effect/TxQueue/Dequeue"
+const TypeId = "~effect/TxQueue"
 
 /**
  * Namespace containing type definitions for TxEnqueue variance annotations.
@@ -916,7 +917,7 @@ export const takeAll = <A, E>(self: TxDequeue<A, E>): Effect.Effect<Arr.NonEmpty
  *
  * **Details**
  *
- * For an open queue, waits until `min(n, capacity)` items are available, then removes that many items. If `n` is less than or equal to zero, returns an empty array without modifying the queue. If the queue is closing, drains the currently available items and transitions to `Done`. If the queue is already done, the effect fails with the queue's completion cause. This function mutates the original TxQueue by removing the taken items. It does not return a new TxQueue reference.
+ * For an open queue, waits until `min(n, capacity)` items are available, then removes that many items. Finite fractional values of `n` are rounded down. If `n` is `NaN` or non-positive, returns an empty array without modifying the queue. If the queue is closing, drains the currently available items and transitions to `Done`. If the queue is already done, the effect fails with the queue's completion cause. This function mutates the original TxQueue by removing the taken items. It does not return a new TxQueue reference.
  *
  * **Example** (Taking a fixed number of values)
  *
@@ -947,7 +948,7 @@ export const takeN: {
    *
    * **Details**
    *
-   * For an open queue, waits until `min(n, capacity)` items are available, then removes that many items. If `n` is less than or equal to zero, returns an empty array without modifying the queue. If the queue is closing, drains the currently available items and transitions to `Done`. If the queue is already done, the effect fails with the queue's completion cause. This function mutates the original TxQueue by removing the taken items. It does not return a new TxQueue reference.
+   * For an open queue, waits until `min(n, capacity)` items are available, then removes that many items. Finite fractional values of `n` are rounded down. If `n` is `NaN` or non-positive, returns an empty array without modifying the queue. If the queue is closing, drains the currently available items and transitions to `Done`. If the queue is already done, the effect fails with the queue's completion cause. This function mutates the original TxQueue by removing the taken items. It does not return a new TxQueue reference.
    *
    * **Example** (Taking a fixed number of values)
    *
@@ -978,7 +979,7 @@ export const takeN: {
    *
    * **Details**
    *
-   * For an open queue, waits until `min(n, capacity)` items are available, then removes that many items. If `n` is less than or equal to zero, returns an empty array without modifying the queue. If the queue is closing, drains the currently available items and transitions to `Done`. If the queue is already done, the effect fails with the queue's completion cause. This function mutates the original TxQueue by removing the taken items. It does not return a new TxQueue reference.
+   * For an open queue, waits until `min(n, capacity)` items are available, then removes that many items. Finite fractional values of `n` are rounded down. If `n` is `NaN` or non-positive, returns an empty array without modifying the queue. If the queue is closing, drains the currently available items and transitions to `Done`. If the queue is already done, the effect fails with the queue's completion cause. This function mutates the original TxQueue by removing the taken items. It does not return a new TxQueue reference.
    *
    * **Example** (Taking a fixed number of values)
    *
@@ -1006,8 +1007,9 @@ export const takeN: {
   <A, E>(self: TxDequeue<A, E>, n: number): Effect.Effect<Array<A>, E>
 } = dual(
   2,
-  <A, E>(self: TxDequeue<A, E>, n: number): Effect.Effect<Array<A>, E> =>
-    Effect.gen(function*() {
+  <A, E>(self: TxDequeue<A, E>, n: number): Effect.Effect<Array<A>, E> => {
+    const requestedCount = Count.normalize(n)
+    return Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
 
       // Check if queue is done - forward the cause directly
@@ -1018,7 +1020,6 @@ export const takeN: {
       const currentSize = yield* size(self)
 
       // Determine how many items we can/should take
-      const requestedCount = n
       const maxPossible = Math.min(requestedCount, self.capacity)
 
       // If we can't get the requested amount due to capacity constraints,
@@ -1059,6 +1060,7 @@ export const takeN: {
 
       return Chunk.toArray(taken)
     }).pipe(Effect.tx)
+  }
 )
 
 /**
@@ -1067,7 +1069,7 @@ export const takeN: {
  *
  * **Details**
  *
- * If the queue is closing, drains the currently available items even when fewer than `min` are available and transitions to `Done`. Invalid ranges (`min <= 0`, `max <= 0`, or `min > max`) return an empty array. If the queue is already done, the effect fails with the queue's completion cause.
+ * Finite fractional bounds are rounded down, while `NaN` and non-positive bounds are treated as `0`. If the queue is closing, drains the currently available items even when fewer than `min` are available and transitions to `Done`. Invalid normalized ranges (`min <= 0`, `max <= 0`, or `min > max`) return an empty array. If the queue is already done, the effect fails with the queue's completion cause.
  *
  * **Example** (Taking batches within bounds)
  *
@@ -1102,7 +1104,7 @@ export const takeBetween: {
    *
    * **Details**
    *
-   * If the queue is closing, drains the currently available items even when fewer than `min` are available and transitions to `Done`. Invalid ranges (`min <= 0`, `max <= 0`, or `min > max`) return an empty array. If the queue is already done, the effect fails with the queue's completion cause.
+   * Finite fractional bounds are rounded down, while `NaN` and non-positive bounds are treated as `0`. If the queue is closing, drains the currently available items even when fewer than `min` are available and transitions to `Done`. Invalid normalized ranges (`min <= 0`, `max <= 0`, or `min > max`) return an empty array. If the queue is already done, the effect fails with the queue's completion cause.
    *
    * **Example** (Taking batches within bounds)
    *
@@ -1137,7 +1139,7 @@ export const takeBetween: {
    *
    * **Details**
    *
-   * If the queue is closing, drains the currently available items even when fewer than `min` are available and transitions to `Done`. Invalid ranges (`min <= 0`, `max <= 0`, or `min > max`) return an empty array. If the queue is already done, the effect fails with the queue's completion cause.
+   * Finite fractional bounds are rounded down, while `NaN` and non-positive bounds are treated as `0`. If the queue is closing, drains the currently available items even when fewer than `min` are available and transitions to `Done`. Invalid normalized ranges (`min <= 0`, `max <= 0`, or `min > max`) return an empty array. If the queue is already done, the effect fails with the queue's completion cause.
    *
    * **Example** (Taking batches within bounds)
    *
@@ -1168,8 +1170,10 @@ export const takeBetween: {
   <A, E>(self: TxDequeue<A, E>, min: number, max: number): Effect.Effect<Array<A>, E>
 } = dual(
   3,
-  <A, E>(self: TxDequeue<A, E>, min: number, max: number): Effect.Effect<Array<A>, E> =>
-    Effect.gen(function*() {
+  <A, E>(self: TxDequeue<A, E>, min: number, max: number): Effect.Effect<Array<A>, E> => {
+    const minimum = Count.normalize(min)
+    const maximum = Count.normalize(max)
+    return Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
 
       // Check if queue is done - forward the cause directly
@@ -1178,14 +1182,14 @@ export const takeBetween: {
       }
 
       // Validate parameters
-      if (min <= 0 || max <= 0 || min > max) {
+      if (minimum <= 0 || maximum <= 0 || minimum > maximum) {
         return []
       }
 
       const currentSize = yield* size(self)
 
       // If we have less than minimum required items
-      if (currentSize < min) {
+      if (currentSize < minimum) {
         // If queue is closing, transition to done and return what we have
         if (state._tag === "Closing") {
           if (yield* isEmpty(self)) {
@@ -1205,7 +1209,7 @@ export const takeBetween: {
       }
 
       // We have at least the minimum, take up to the maximum
-      const toTake = Math.min(currentSize, max)
+      const toTake = Math.min(currentSize, maximum)
       const chunk = yield* TxChunk.get(self.items)
       const taken = Chunk.take(chunk, toTake)
       yield* TxChunk.drop(self.items, toTake)
@@ -1217,6 +1221,7 @@ export const takeBetween: {
 
       return Chunk.toArray(taken)
     }).pipe(Effect.tx)
+  }
 )
 
 /**