effect 4.0.0-beta.100 → 4.0.0-beta.102

package/src/SchemaTransformation.ts

@@ -195,7 +195,7 @@ export class Transformation<in out T, in out E, RD = never, RE = never> {
  * @since 4.0.0
  */
 export function isTransformation(u: unknown): u is Transformation<any, any, unknown, unknown> {
-  return Predicate.hasProperty(u, TypeId)
+  return Predicate.hasProperty(u, TypeId) && u[TypeId] === TypeId
 }
 
 /**
@@ -852,8 +852,8 @@ export const bigintFromString = new Transformation(
  *
  * **When to use**
  *
- * Use when you need a schema transformation to parse ISO 8601 date strings from
- * APIs or user input.
+ * Use when you need a schema transformation to parse date strings from APIs or
+ * user input.
  *
  * **Details**
  *

package/src/Semaphore.ts

@@ -118,9 +118,11 @@ export interface Semaphore {
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>
 
   /**
-   * Acquires the specified number of permits and returns the resulting
-   * available permits, suspending the task if they are not yet available.
-   * Concurrent pending `take` calls are processed in a first-in, first-out manner.
+   * Acquires the specified number of permits and returns the acquired permit
+   * count, suspending the task if they are not yet available. Pending `take`
+   * calls are scanned in registration order, but a request is served only when
+   * enough permits are available, so a smaller later request may overtake a
+   * larger earlier request.
    *
    * **When to use**
    *

package/src/Stream.ts

@@ -9311,7 +9311,8 @@ export const catchReasons: {
     }[keyof Cases]
   >
 } = dual((args) => isStream(args[0]), (self, errorTag, cases, orElse) => {
-  const handlers: Record<string, (reason: any, error: any) => Channel.Channel<any, any, any, any, any, any, any>> = {}
+  const handlers: Record<string, (reason: any, error: any) => Channel.Channel<any, any, any, any, any, any, any>> =
+    Object.create(null)
   for (const key of Object.keys(cases)) {
     const handler = (cases as any)[key]
     handlers[key] = (reason, error) => handler(reason, error).channel
@@ -17133,7 +17134,7 @@ export const interruptWhen: {
 )
 
 /**
- * Stops a stream after the current element when an effect completes.
+ * Stops a stream after the current pull when an effect completes.
  *
  * **When to use**
  *
@@ -17146,8 +17147,10 @@ export const interruptWhen: {
  *
  * **Gotchas**
  *
- * This does not interrupt an in-progress pull. Use {@link interruptWhen} when
- * the stream should be interrupted immediately.
+ * This does not interrupt or truncate an in-progress pull. A pull may emit
+ * multiple elements in a single chunk, in which case the entire chunk is
+ * emitted. Use {@link interruptWhen} when the stream should be interrupted
+ * immediately.
  *
  * **Example** (Halting a stream after an effect completes)
  *
@@ -17174,7 +17177,7 @@ export const interruptWhen: {
  */
 export const haltWhen: {
   /**
-   * Stops a stream after the current element when an effect completes.
+   * Stops a stream after the current pull when an effect completes.
    *
    * **When to use**
    *
@@ -17187,8 +17190,10 @@ export const haltWhen: {
    *
    * **Gotchas**
    *
-   * This does not interrupt an in-progress pull. Use {@link interruptWhen} when
-   * the stream should be interrupted immediately.
+   * This does not interrupt or truncate an in-progress pull. A pull may emit
+   * multiple elements in a single chunk, in which case the entire chunk is
+   * emitted. Use {@link interruptWhen} when the stream should be interrupted
+   * immediately.
    *
    * **Example** (Halting a stream after an effect completes)
    *
@@ -17215,7 +17220,7 @@ export const haltWhen: {
    */
   <X, E2, R2>(effect: Effect.Effect<X, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   /**
-   * Stops a stream after the current element when an effect completes.
+   * Stops a stream after the current pull when an effect completes.
    *
    * **When to use**
    *
@@ -17228,8 +17233,10 @@ export const haltWhen: {
    *
    * **Gotchas**
    *
-   * This does not interrupt an in-progress pull. Use {@link interruptWhen} when
-   * the stream should be interrupted immediately.
+   * This does not interrupt or truncate an in-progress pull. A pull may emit
+   * multiple elements in a single chunk, in which case the entire chunk is
+   * emitted. Use {@link interruptWhen} when the stream should be interrupted
+   * immediately.
    *
    * **Example** (Halting a stream after an effect completes)
    *
@@ -20193,32 +20200,69 @@ export const toAsyncIterableWith: {
   ): AsyncIterable<A> => ({
     [Symbol.asyncIterator]() {
       const runPromise = Effect.runPromiseWith(context)
-      const runPromiseExit = Effect.runPromiseExitWith(context)
+      const runFork = Effect.runForkWith(context)
       const scope = Scope.makeUnsafe()
       let pull: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void, R> | undefined
       let currentIter: Iterator<A> | undefined
+      let currentFiber: Fiber.Fiber<Arr.NonEmptyReadonlyArray<A>, E | Cause.Done<void>> | undefined
+      let closePromise: Promise<IteratorResult<A>> | undefined
+      const close = (exit: Exit.Exit<unknown, unknown>): Promise<IteratorResult<A>> => {
+        if (closePromise) return closePromise
+        const fiber = currentFiber
+        closePromise = runPromise(Effect.as(
+          Effect.andThen(
+            fiber ? Fiber.interrupt(fiber) : Effect.void,
+            Scope.close(scope, exit)
+          ),
+          { done: true, value: undefined }
+        ))
+        return closePromise
+      }
+      const closeAndReportError = async (exit: Exit.Exit<unknown, unknown>): Promise<void> => {
+        try {
+          await close(exit)
+        } catch (error) {
+          await runPromise(Effect.logError("Suppressed error while closing Stream async iterator", error))
+        }
+      }
       return {
         async next(): Promise<IteratorResult<A>> {
+          if (closePromise) return closePromise
           if (currentIter) {
             const next = currentIter.next()
             if (!next.done) return next
             currentIter = undefined
           }
-          pull ??= await runPromise(Channel.toPullScoped(self.channel, scope))
-          const exit = await runPromiseExit(pull)
+          const fiber = runFork(
+            pull ??
+              Effect.flatMap(Channel.toPullScoped(self.channel, scope), (nextPull) => {
+                pull = nextPull
+                return nextPull
+              })
+          )
+          currentFiber = fiber
+          const exit = await runPromise(Fiber.await(fiber))
+          if (currentFiber === fiber) {
+            currentFiber = undefined
+          }
           if (Exit.isSuccess(exit)) {
             currentIter = exit.value[Symbol.iterator]()
             return currentIter.next()
           } else if (Pull.isDoneCause(exit.cause)) {
-            return { done: true, value: undefined }
+            return close(Exit.void)
           }
+          if (closePromise && Cause.hasInterruptsOnly(exit.cause)) {
+            return closePromise
+          }
+          await closeAndReportError(exit)
           throw Cause.squash(exit.cause)
         },
-        return(_) {
-          return runPromise(Effect.as(
-            Scope.close(scope, Exit.void),
-            { done: true, value: undefined }
-          ))
+        return() {
+          return close(Exit.void)
+        },
+        async throw(error) {
+          await closeAndReportError(Exit.die(error))
+          throw error
         }
       }
     }

package/src/Struct.ts

@@ -14,6 +14,7 @@
 import * as Combiner from "./Combiner.ts"
 import * as Equivalence from "./Equivalence.ts"
 import { dual } from "./Function.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as order from "./Order.ts"
 import * as Reducer from "./Reducer.ts"
 
@@ -1464,7 +1465,7 @@ function buildStruct<
     const res = f(k, source[k])
     if (res) {
       const [nk, nv] = res
-      out[nk] = nv
+      InternalRecord.assignProperty(out, nk, nv)
     }
   }
   return out
@@ -1516,7 +1517,7 @@ export function makeCombiner<A>(
     for (const key of keys) {
       const merge = combiners[key].combine(self[key], that[key])
       if (omitKeyWhen(merge)) continue
-      out[key] = merge
+      InternalRecord.assignProperty(out as object, key, merge)
     }
     return out
   })
@@ -1571,7 +1572,7 @@ export function makeReducer<A>(
   for (const key of Reflect.ownKeys(reducers) as Array<keyof A>) {
     const iv = reducers[key].initialValue
     if (options?.omitKeyWhen?.(iv)) continue
-    initialValue[key] = iv
+    InternalRecord.assignProperty(initialValue as object, key, iv)
   }
   return Reducer.make(combine, initialValue)
 }
@@ -1601,7 +1602,7 @@ export function Record<const Keys extends ReadonlyArray<string | symbol>, Value>
 ): Record<Keys[number], Value> {
   const out: any = {}
   for (const key of keys) {
-    out[key] = value
+    InternalRecord.assignProperty(out, key, value)
   }
   return out
 }

package/src/Types.ts

@@ -421,7 +421,6 @@ export type MergeRight<Target, Source> = Simplify<
  *
  * - `number` — run at most N effects concurrently.
  * - `"unbounded"` — run all effects concurrently with no limit.
- * - `"inherit"` — inherit the concurrency from the surrounding context.
  *
  * **Example** (Setting concurrency values)
  *
@@ -431,13 +430,12 @@ export type MergeRight<Target, Source> = Simplify<
  * const sequential: Types.Concurrency = 1
  * const limited: Types.Concurrency = 5
  * const unbounded: Types.Concurrency = "unbounded"
- * const inherit: Types.Concurrency = "inherit"
  * ```
  *
  * @category models
  * @since 2.0.0
  */
-export type Concurrency = number | "unbounded" | "inherit"
+export type Concurrency = number | "unbounded"
 
 /**
  * Removes `readonly` from all properties of `T`. Supports arrays, tuples,

package/src/index.ts

@@ -556,11 +556,6 @@ export * as SchemaRepresentation from "./SchemaRepresentation.ts"
  */
 export * as SchemaTransformation from "./SchemaTransformation.ts"
 
-/**
- * @since 4.0.0
- */
-export * as SchemaUtils from "./SchemaUtils.ts"
-
 /**
  * @since 2.0.0
  */

package/src/internal/core.ts

@@ -13,6 +13,7 @@ import type { StackFrame } from "../References.ts"
 import type * as Types from "../Types.ts"
 import { SingleShotGen } from "../Utils.ts"
 import type { FiberImpl } from "./effect.ts"
+import * as InternalRecord from "./record.ts"
 
 /** @internal */
 export const EffectTypeId = `~effect/Effect` as const
@@ -541,7 +542,7 @@ export const exitFailCause: <E>(cause: Cause.Cause<E>) => Exit.Exit<never, E> =
     }
     return cont
       ? cont[contE](cause, fiber, annotated ? undefined : this)
-      : fiber.yieldWith(annotated ? this : exitFailCause(cause))
+      : fiber.yieldWith(annotated ? exitFailCause(cause) : this)
   }
 })
 
@@ -587,10 +588,10 @@ export const Error: new<A extends Record<string, any> = {}>(
 ) => Cause.YieldableError & Readonly<A> = (function() {
   const plainArgsSymbol = Symbol.for("effect/Data/Error/plainArgs")
   return class Base extends YieldableError {
-    constructor(args: any) {
+    constructor(args: Record<string, any> | undefined) {
       super(args?.message, args?.cause ? { cause: args.cause } : undefined)
       if (args) {
-        Object.assign(this, args)
+        InternalRecord.assignProperties(this, args)
         // @effect-diagnostics-next-line floatingEffect:off
         Object.defineProperty(this, plainArgsSymbol, {
           value: args,