effect 4.0.0-beta.40 → 4.0.0-beta.42

package/src/Effect.ts

@@ -15966,6 +15966,7 @@ export interface RunOptions {
   readonly signal?: AbortSignal | undefined
   readonly scheduler?: Scheduler | undefined
   readonly uninterruptible?: boolean | undefined
+  readonly onFiberStart?: ((fiber: Fiber<unknown, unknown>) => void) | undefined
 }
 
 /**
@@ -22603,107 +22604,56 @@ export class Transaction extends ServiceMap.Service<
   }
 >()("effect/Effect/Transaction") {}
 
-/**
- * Accesses the current transaction state within an active transaction.
- *
- * This function requires `Transaction` in the context and does NOT create or strip
- * transaction boundaries. Use it to interact with the transaction journal (e.g. in
- * `TxRef` internals). To define a transaction boundary, use {@link transaction}.
- *
- * @example
- * ```ts
- * import { Effect, TxRef } from "effect"
- *
- * const program = Effect.gen(function*() {
- *   const ref = yield* Effect.transaction(TxRef.make(0))
- *
- *   yield* Effect.transaction(Effect.gen(function*() {
- *     yield* TxRef.set(ref, 42)
- *     return yield* TxRef.get(ref)
- *   }))
- * })
- * ```
- *
- * @since 4.0.0
- * @category Transactions
- */
-export const withTxState = <A, E, R>(
-  f: (state: Transaction["Service"]) => Effect<A, E, R>
-): Effect<A, E, R | Transaction> =>
-  flatMap(
-    Transaction.asEffect(),
-    (state) => internalCall(() => f(state))
-  )
-
 /**
  * Defines a transaction boundary. Transactions are "all or nothing" with respect to changes
  * made to transactional values (i.e. TxRef) that occur within the transaction body.
  *
+ * If called inside an active transaction, `tx` composes with the current transaction and reuses
+ * its journal and retry state instead of creating a nested boundary.
+ *
  * In Effect transactions are optimistic with retry, that means transactions are retried when:
  *
- * - the body of the transaction explicitely calls to `Effect.retryTransaction` and any of the
+ * - the body of the transaction explicitely calls to `Effect.txRetry` and any of the
  *   accessed transactional values changes.
  *
  * - any of the accessed transactional values change during the execution of the transaction
  *   due to a different transaction committing before the current.
  *
- * Each call to `transaction` always creates a new isolated transaction boundary with its own
- * journal and retry logic.
+ * The outermost `tx` call creates the transaction boundary and commits or rolls back the full
+ * composed transaction.
  *
  * @example
  * ```ts
  * import { Effect, TxRef } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   const ref1 = yield* Effect.transaction(TxRef.make(0))
- *   const ref2 = yield* Effect.transaction(TxRef.make(0))
+ *   const ref1 = yield* TxRef.make(0)
+ *   const ref2 = yield* TxRef.make(0)
  *
- *   // All operations within transaction block succeed or fail together
- *   yield* Effect.transaction(Effect.gen(function*() {
+ *   // Nested tx calls compose into the same transaction
+ *   yield* Effect.tx(Effect.gen(function*() {
  *     yield* TxRef.set(ref1, 10)
- *     yield* TxRef.set(ref2, 20)
+ *     yield* Effect.tx(TxRef.set(ref2, 20))
  *     const sum = (yield* TxRef.get(ref1)) + (yield* TxRef.get(ref2))
  *     console.log(`Transaction sum: ${sum}`)
  *   }))
  *
- *   console.log(`Final ref1: ${yield* Effect.transaction(TxRef.get(ref1))}`) // 10
- *   console.log(`Final ref2: ${yield* Effect.transaction(TxRef.get(ref2))}`) // 20
+ *   console.log(`Final ref1: ${yield* TxRef.get(ref1)}`) // 10
+ *   console.log(`Final ref2: ${yield* TxRef.get(ref2)}`) // 20
  * })
  * ```
  *
  * @since 4.0.0
  * @category Transactions
  */
-export const transaction = <A, E, R>(
+export const tx = <A, E, R>(
   effect: Effect<A, E, R>
-): Effect<A, E, Exclude<R, Transaction>> => transactionWith(() => effect)
-
-/**
- * Like {@link transaction} but provides access to the transaction state.
- *
- * Always creates a new isolated transaction boundary with its own journal and retry logic.
- *
- * @example
- * ```ts
- * import { Effect, TxRef } from "effect"
- *
- * const program = Effect.transactionWith((_txState) =>
- *   Effect.gen(function*() {
- *     const ref = yield* TxRef.make(0)
- *     yield* TxRef.set(ref, 42)
- *     return yield* TxRef.get(ref)
- *   })
- * )
- * ```
- *
- * @since 4.0.0
- * @category Transactions
- */
-export const transactionWith = <A, E, R>(
-  f: (state: Transaction["Service"]) => Effect<A, E, R>
 ): Effect<A, E, Exclude<R, Transaction>> =>
   withFiber((fiber) => {
-    // Always create a new transaction state, never compose with parent
+    if (fiber.services.mapUnsafe.has(Transaction.key)) {
+      return effect as Effect<A, E, Exclude<R, Transaction>>
+    }
+    // Create transaction state only at the outermost boundary
     const state: Transaction["Service"] = { journal: new Map(), retry: false }
     let result: Exit.Exit<A, E> | undefined
     return uninterruptibleMask((restore) =>
@@ -22711,7 +22661,7 @@ export const transactionWith = <A, E, R>(
         whileLoop({
           while: () => !result,
           body: constant(
-            restore(suspend(() => f(state))).pipe(
+            restore(effect).pipe(
               provideService(Transaction, state),
               tapCause(() => {
                 if (!state.retry) return void_
@@ -22800,20 +22750,20 @@ function clearTransaction(state: Transaction["Service"]) {
  *
  * const program = Effect.gen(function*() {
  *   // create a transactional reference
- *   const ref = yield* Effect.transaction(TxRef.make(0))
+ *   const ref = yield* TxRef.make(0)
  *
  *   // forks a fiber that increases the value of `ref` every 100 millis
  *   yield* Effect.forkChild(Effect.forever(
  *     // update to transactional value
- *     Effect.transaction(TxRef.update(ref, (n) => n + 1)).pipe(Effect.delay("100 millis"))
+ *     Effect.tx(TxRef.update(ref, (n) => n + 1)).pipe(Effect.delay("100 millis"))
  *   ))
  *
  *   // the following will retry 10 times until the `ref` value is 10
- *   yield* Effect.transaction(Effect.gen(function*() {
+ *   yield* Effect.tx(Effect.gen(function*() {
  *     const value = yield* TxRef.get(ref)
  *     if (value < 10) {
  *       yield* Effect.log(`retry due to value: ${value}`)
- *       return yield* Effect.retryTransaction
+ *       return yield* Effect.txRetry
  *     }
  *     yield* Effect.log(`transaction done with value: ${value}`)
  *   }))
@@ -22822,7 +22772,7 @@ function clearTransaction(state: Transaction["Service"]) {
  * Effect.runPromise(program).catch(console.error)
  * ```
  */
-export const retryTransaction: Effect<never, never, Transaction> = flatMap(
+export const txRetry: Effect<never, never, Transaction> = flatMap(
   Transaction.asEffect(),
   (state) => {
     state.retry = true

package/src/Layer.ts

@@ -3024,7 +3024,7 @@ export const updateService: {
     layer: Layer<A1, E1, R1>,
     service: ServiceMap.Key<I, A>,
     f: (a: A) => A
-  ): Layer<A1, E1, I | R1> => provide(layer, effect(service)(internalEffect.map(service.asEffect(), f)))
+  ): Layer<A1, E1, I | R1> => provide(layer, effect(service, internalEffect.map(service.asEffect(), f)))
 )
 
 /**

package/src/ManagedRuntime.ts

@@ -164,22 +164,35 @@ export const make = <R, ER>(
   } | undefined
 ): ManagedRuntime<R, ER> => {
   const memoMap = options?.memoMap ?? Layer.makeMemoMapUnsafe()
-  const scope = Scope.makeUnsafe()
+  const scope = Scope.makeUnsafe("parallel")
+  const layerScope = Scope.forkUnsafe(scope, "sequential")
+  const defaultRunOptions: Effect.RunOptions = {
+    onFiberStart: Fiber.runIn(scope)
+  }
+  const mergeRunOptions = <O extends Effect.RunOptions>(options?: O): O =>
+    options
+      ? {
+        ...options,
+        onFiberStart: options.onFiberStart ?
+          (fiber) => {
+            defaultRunOptions.onFiberStart!(fiber)
+            options.onFiberStart!(fiber)
+          } :
+          defaultRunOptions.onFiberStart
+      }
+      : defaultRunOptions as O
   let buildFiber: Fiber.Fiber<ServiceMap.ServiceMap<R>, ER> | undefined
   const servicesEffect = Effect.withFiber<ServiceMap.ServiceMap<R>, ER>((fiber) => {
     if (!buildFiber) {
-      buildFiber = Fiber.runIn(
-        Effect.runFork(
-          Effect.tap(
-            Layer.buildWithMemoMap(layer, memoMap, scope),
-            (services) =>
-              Effect.sync(() => {
-                self.cachedServices = services
-              })
-          ),
-          { scheduler: fiber.currentScheduler }
+      buildFiber = Effect.runFork(
+        Effect.tap(
+          Layer.buildWithMemoMap(layer, memoMap, layerScope),
+          (services) =>
+            Effect.sync(() => {
+              self.cachedServices = services
+            })
         ),
-        scope
+        { ...defaultRunOptions, scheduler: fiber.currentScheduler }
       )
     }
     return Effect.flatten(Fiber.await(buildFiber))
@@ -205,8 +218,8 @@ export const make = <R, ER>(
     }),
     runFork<A, E>(effect: Effect.Effect<A, E, R>, options?: Effect.RunOptions): Fiber.Fiber<A, E | ER> {
       return self.cachedServices === undefined ?
-        Effect.runFork(provide(self, effect), options) :
-        Effect.runForkWith(self.cachedServices)(effect, options)
+        Effect.runFork(provide(self, effect), mergeRunOptions(options)) :
+        Effect.runForkWith(self.cachedServices)(effect, mergeRunOptions(options))
     },
     runCallback<A, E>(
       effect: Effect.Effect<A, E, R>,
@@ -215,8 +228,8 @@ export const make = <R, ER>(
       }
     ): (interruptor?: number | undefined) => void {
       return self.cachedServices === undefined ?
-        Effect.runCallback(provide(self, effect), options) :
-        Effect.runCallbackWith(self.cachedServices)(effect, options)
+        Effect.runCallback(provide(self, effect), mergeRunOptions(options)) :
+        Effect.runCallbackWith(self.cachedServices)(effect, mergeRunOptions(options))
     },
     runSyncExit<A, E>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E | ER> {
       return self.cachedServices === undefined ?
@@ -230,15 +243,15 @@ export const make = <R, ER>(
     },
     runPromiseExit<A, E>(effect: Effect.Effect<A, E, R>, options?: Effect.RunOptions): Promise<Exit.Exit<A, E | ER>> {
       return self.cachedServices === undefined ?
-        Effect.runPromiseExit(provide(self, effect), options) :
-        Effect.runPromiseExitWith(self.cachedServices)(effect, options)
+        Effect.runPromiseExit(provide(self, effect), mergeRunOptions(options)) :
+        Effect.runPromiseExitWith(self.cachedServices)(effect, mergeRunOptions(options))
     },
     runPromise<A, E>(effect: Effect.Effect<A, E, R>, options?: {
       readonly signal?: AbortSignal | undefined
     }): Promise<A> {
       return self.cachedServices === undefined ?
-        Effect.runPromise(provide(self, effect), options) :
-        Effect.runPromiseWith(self.cachedServices)(effect, options)
+        Effect.runPromise(provide(self, effect), mergeRunOptions(options)) :
+        Effect.runPromiseWith(self.cachedServices)(effect, mergeRunOptions(options))
     }
   }
   return self

package/src/MutableList.ts

@@ -507,6 +507,9 @@ export const appendAll = <A>(self: MutableList<A>, messages: Iterable<A>): numbe
  * @category mutations
  */
 export const appendAllUnsafe = <A>(self: MutableList<A>, messages: ReadonlyArray<A>, mutable = false): number => {
+  if (messages.length === 0) {
+    return 0
+  }
   const chunk: MutableList.Bucket<A> = {
     array: messages as Array<A>,
     mutable,

package/src/Number.ts

@@ -957,15 +957,25 @@ export const remainder: {
    */
   (self: number, divisor: number): number
 } = dual(2, (self: number, divisor: number): number => {
-  // https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034
-  const selfDecCount = (self.toString().split(".")[1] || "").length
-  const divisorDecCount = (divisor.toString().split(".")[1] || "").length
+  const selfDecCount = decimalCount(self)
+  const divisorDecCount = decimalCount(divisor)
   const decCount = selfDecCount > divisorDecCount ? selfDecCount : divisorDecCount
   const selfInt = parseInt(self.toFixed(decCount).replace(".", ""))
   const divisorInt = parseInt(divisor.toFixed(decCount).replace(".", ""))
   return (selfInt % divisorInt) / Math.pow(10, decCount)
 })
 
+function decimalCount(n: number): number {
+  const s = n.toString()
+  const eIndex = s.indexOf("e-")
+  if (eIndex !== -1) {
+    const exp = parseInt(s.slice(eIndex + 2))
+    const mantissaDecimals = (s.slice(0, eIndex).split(".")[1] || "").length
+    return mantissaDecimals + exp
+  }
+  return (s.split(".")[1] || "").length
+}
+
 /**
  * Returns the next power of 2 from the given number.
  *

package/src/SchemaRepresentation.ts

@@ -3015,7 +3015,13 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
     }
 
     if (Array.isArray(js.allOf)) {
-      return js.allOf.reduce((acc, curr) => combine(acc, recur(curr)), out)
+      out = js.allOf.reduce((acc, curr) => combine(acc, recur(curr)), out)
+    }
+    if (Array.isArray(js.anyOf)) {
+      out = combine({ _tag: "Union", types: js.anyOf.map((type) => recur(type)), mode: "anyOf" }, out)
+    }
+    if (Array.isArray(js.oneOf)) {
+      out = combine({ _tag: "Union", types: js.oneOf.map((type) => recur(type)), mode: "oneOf" }, out)
     }
 
     return out
@@ -3054,10 +3060,6 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
       } else {
         return { _tag: "Union", types, mode: "anyOf" }
       }
-    } else if (Array.isArray(js.anyOf)) {
-      return { _tag: "Union", types: js.anyOf.map((type) => recur(type)), mode: "anyOf" }
-    } else if (Array.isArray(js.oneOf)) {
-      return { _tag: "Union", types: js.oneOf.map((type) => recur(type)), mode: "oneOf" }
     }
 
     const type = isType(js.type) ? js.type : getType(js)
@@ -3290,7 +3292,7 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
             return {
               _tag: "Union",
               types,
-              mode: "anyOf",
+              mode: a.mode,
               ...makeAnnotations(a.annotations)
             }
           }

package/src/ServiceMap.ts

@@ -22,7 +22,17 @@ import type { Pipeable } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import type * as Types from "./Types.ts"
 
-const ServiceTypeId = "~effect/ServiceMap/Service" as const
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export type ServiceTypeId = "~effect/ServiceMap/Service"
+
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const ServiceTypeId: ServiceTypeId = "~effect/ServiceMap/Service"
 
 /**
  * The base type used for all ServiceMap keys.
@@ -30,11 +40,8 @@ const ServiceTypeId = "~effect/ServiceMap/Service" as const
  * @since 4.0.0
  * @category Models
  */
-export interface Key<in out Identifier, in out Shape> extends Pipeable, Inspectable {
-  readonly [ServiceTypeId]: {
-    readonly _Service: Types.Invariant<Shape>
-    readonly _Identifier: Types.Invariant<Identifier>
-  }
+export interface Key<out Identifier, out Shape> extends Pipeable, Inspectable {
+  readonly [ServiceTypeId]: ServiceTypeId
   readonly Service: Shape
   readonly Identifier: Identifier
   readonly key: string
@@ -262,10 +269,7 @@ export const Service: {
 } as any
 
 const ServiceProto: any = {
-  [ServiceTypeId]: {
-    _Service: (_: unknown) => _,
-    _Identifier: (_: unknown) => _
-  },
+  [ServiceTypeId]: ServiceTypeId,
   ...PipeInspectableProto,
   ...YieldableProto,
   toJSON<I, A>(this: Service<I, A>) {
@@ -344,25 +348,6 @@ export interface Reference<in out Shape> extends Service<never, Shape> {
  * @category Models
  */
 export declare namespace Service {
-  /**
-   * @example
-   * ```ts
-   * import type { ServiceMap } from "effect"
-   *
-   * // Variance interface is used internally for type inference
-   * type MyVariance = ServiceMap.Service.Variance<"MyId", { value: number }>
-   * ```
-   *
-   * @since 4.0.0
-   * @category Models
-   */
-  export interface Variance<in out Identifier, in out Shape> {
-    readonly [ServiceTypeId]: {
-      readonly _Service: Types.Invariant<Shape>
-      readonly _Identifier: Types.Invariant<Identifier>
-    }
-  }
-
   /**
    * @example
    * ```ts
@@ -397,7 +382,7 @@ export declare namespace Service {
    * @since 4.0.0
    * @category Models
    */
-  export type Shape<T> = T extends Variance<infer _I, infer S> ? S : never
+  export type Shape<T> = T extends Key<infer _I, infer S> ? S : never
 
   /**
    * @example
@@ -416,7 +401,7 @@ export declare namespace Service {
    * @since 4.0.0
    * @category Models
    */
-  export type Identifier<T> = T extends Variance<infer I, infer _S> ? I : never
+  export type Identifier<T> = T extends Key<infer I, infer _S> ? I : never
 }
 
 const TypeId = "~effect/ServiceMap" as const