effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/Request.ts

@@ -14,6 +14,7 @@
  * @since 2.0.0
  */
 import type * as Cause from "./Cause.ts"
+import type * as Context from "./Context.ts"
 import type * as Effect from "./Effect.ts"
 import * as Equal from "./Equal.ts"
 import type * as Exit from "./Exit.ts"
@@ -21,7 +22,6 @@ import { dual } from "./Function.ts"
 import * as core from "./internal/core.ts"
 import * as internalEffect from "./internal/effect.ts"
 import { hasProperty } from "./Predicate.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 import type * as Types from "./Types.ts"
 
 const TypeId = "~effect/Request"
@@ -88,7 +88,7 @@ export interface Variance<out A, out E, out R> {
  * @category models
  */
 export interface Constructor<R extends Request<any, any, any>, T extends keyof R = never> {
-  (args: Omit<R, T | keyof (Variance<any, any, any>)>): R
+  (args: Types.VoidIfEmpty<Types.Simplify<Omit<R, T | keyof (Variance<any, any, any>)>>>): R
 }
 
 /**
@@ -285,7 +285,8 @@ export const tagged = <R extends Request<any, any, any> & { _tag: string }>(
   tag: R["_tag"]
 ): Constructor<R, "_tag"> =>
 (args) => {
-  const request = Object.assign(Object.create(RequestPrototype), args)
+  const request = Object.create(RequestPrototype)
+  if (args) Object.assign(request, args)
   request._tag = tag
   return request
 }
@@ -308,10 +309,10 @@ export const tagged = <R extends Request<any, any, any> & { _tag: string }>(
  * @since 2.0.0
  * @category constructors
  */
-export const Class: new<A extends Record<string, any>, Success, Error = never, ServiceMap = never>(
+export const Class: new<A extends Record<string, any>, Success, Error = never, Context = never>(
   args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P] }
-) => Request<Success, Error, ServiceMap> & Readonly<A> = (function() {
+) => Request<Success, Error, Context> & Readonly<A> = (function() {
   function Class(this: any, args: any) {
     if (args) {
       Object.assign(this, args)
@@ -471,7 +472,7 @@ export const succeed: {
  */
 export interface Entry<out R> {
   readonly request: R
-  readonly services: ServiceMap.ServiceMap<
+  readonly context: Context.Context<
     [R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never
   >
   uninterruptible: boolean
@@ -489,7 +490,7 @@ export interface Entry<out R> {
  */
 export const makeEntry = <R>(options: {
   readonly request: R
-  readonly services: ServiceMap.ServiceMap<
+  readonly context: Context.Context<
     [R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never
   >
   readonly uninterruptible: boolean

package/src/RequestResolver.ts

@@ -4,6 +4,7 @@
 import type { NonEmptyArray } from "./Array.ts"
 import * as Arr from "./Array.ts"
 import * as Cache from "./Cache.ts"
+import * as Context from "./Context.ts"
 import type * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
@@ -18,7 +19,6 @@ import { hasProperty } from "./Predicate.ts"
 import type * as Request from "./Request.ts"
 import type * as Schema from "./Schema.ts"
 import type { Scope } from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import * as Tracer from "./Tracer.ts"
 import type * as Types from "./Types.ts"
 import type * as Persistable from "./unstable/persistence/Persistable.ts"
@@ -181,7 +181,7 @@ const defaultKey = (_request: unknown): unknown => defaultKeyObject
  * )
  *
  * // Use the resolver to handle requests
- * const getUserEffect = Effect.request(GetUserRequest({ id: 123 }), Effect.succeed(UserResolver))
+ * const getUserEffect = Effect.request(GetUserRequest({ id: 123 }), UserResolver)
  * ```
  *
  * @since 2.0.0
@@ -276,7 +276,7 @@ const hashGroupKey = <A, K>(get: (entry: Request.Entry<A>) => K) => {
  * // Usage
  * const getSquareEffect = Effect.request(
  *   GetSquareRequest({ value: 5 }),
- *   Effect.succeed(SquareResolver)
+ *   SquareResolver
  * )
  * // Will resolve to 25
  * ```
@@ -319,7 +319,7 @@ export const fromFunction = <A extends Request.Any>(
  *
  * // Usage with multiple requests
  * const effects = [1, 2, 3].map((value) =>
- *   Effect.request(GetDoubleRequest({ value }), Effect.succeed(DoubleResolver))
+ *   Effect.request(GetDoubleRequest({ value }), DoubleResolver)
  * )
  * const batchedEffect = Effect.all(effects) // [2, 4, 6]
  * ```
@@ -370,7 +370,7 @@ export const fromFunctionBatched = <A extends Request.Any>(
  * // Usage
  * const getUserEffect = Effect.request(
  *   GetUserFromAPIRequest({ id: 123 }),
- *   Effect.succeed(UserAPIResolver)
+ *   UserAPIResolver
  * )
  * ```
  *
@@ -652,7 +652,7 @@ export const setDelay: {
    * @since 4.0.0
    * @category delay
    */
-  (duration: Duration.DurationInput): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>
+  (duration: Duration.Input): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>
   /**
    * Sets the batch delay window for this request resolver to the specified duration.
    *
@@ -683,10 +683,10 @@ export const setDelay: {
    * @since 4.0.0
    * @category delay
    */
-  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.DurationInput): RequestResolver<A>
+  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A>
 } = dual(
   2,
-  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.DurationInput): RequestResolver<A> =>
+  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A> =>
     makeWith({
       ...self,
       delay: Effect.sleep(duration)
@@ -841,26 +841,6 @@ export const around: {
 /**
  * A request resolver that never executes requests.
  *
- * @example
- * ```ts
- * import { Effect, Request, RequestResolver } from "effect"
- *
- * // A resolver that will never complete
- * const neverResolver = RequestResolver.never
- *
- * // For testing timeout behavior with any request type
- * interface TestRequest extends Request.Request<string> {
- *   readonly _tag: "TestRequest"
- * }
- * const TestRequest = Request.tagged<TestRequest>("TestRequest")
- *
- * // This will never resolve
- * const neverEffect = Effect.request(TestRequest({}), Effect.succeed(neverResolver) as any)
- *
- * // Useful for testing timeout behavior
- * const timeoutTest = Effect.timeout(neverEffect, "1 second")
- * ```
- *
  * @since 2.0.0
  * @category constructors
  */
@@ -894,7 +874,7 @@ export const never: RequestResolver<never> = make(() => Effect.never)
  * // When more than 5 requests are made, they'll be split into multiple batches
  * const requests = Array.from(
  *   { length: 12 },
- *   (_, i) => Effect.request(GetDataRequest({ id: i }), Effect.succeed(limitedResolver))
+ *   (_, i) => Effect.request(GetDataRequest({ id: i }), limitedResolver)
  * )
  * ```
  *
@@ -930,7 +910,7 @@ export const batchN: {
    * // When more than 5 requests are made, they'll be split into multiple batches
    * const requests = Array.from(
    *   { length: 12 },
-   *   (_, i) => Effect.request(GetDataRequest({ id: i }), Effect.succeed(limitedResolver))
+   *   (_, i) => Effect.request(GetDataRequest({ id: i }), limitedResolver)
    * )
    * ```
    *
@@ -966,7 +946,7 @@ export const batchN: {
    * // When more than 5 requests are made, they'll be split into multiple batches
    * const requests = Array.from(
    *   { length: 12 },
-   *   (_, i) => Effect.request(GetDataRequest({ id: i }), Effect.succeed(limitedResolver))
+   *   (_, i) => Effect.request(GetDataRequest({ id: i }), limitedResolver)
    * )
    * ```
    *
@@ -1014,15 +994,15 @@ export const batchN: {
  * const requests = [
  *   Effect.request(
  *     GetUserRequest({ userId: 1, department: "Engineering" }),
- *     Effect.succeed(groupedResolver)
+ *     groupedResolver
  *   ),
  *   Effect.request(
  *     GetUserRequest({ userId: 2, department: "Engineering" }),
- *     Effect.succeed(groupedResolver)
+ *     groupedResolver
  *   ),
  *   Effect.request(
  *     GetUserRequest({ userId: 3, department: "Marketing" }),
- *     Effect.succeed(groupedResolver)
+ *     groupedResolver
  *   )
  * ]
  * ```
@@ -1065,15 +1045,15 @@ export const grouped: {
    * const requests = [
    *   Effect.request(
    *     GetUserRequest({ userId: 1, department: "Engineering" }),
-   *     Effect.succeed(groupedResolver)
+   *     groupedResolver
    *   ),
    *   Effect.request(
    *     GetUserRequest({ userId: 2, department: "Engineering" }),
-   *     Effect.succeed(groupedResolver)
+   *     groupedResolver
    *   ),
    *   Effect.request(
    *     GetUserRequest({ userId: 3, department: "Marketing" }),
-   *     Effect.succeed(groupedResolver)
+   *     groupedResolver
    *   )
    * ]
    * ```
@@ -1116,15 +1096,15 @@ export const grouped: {
    * const requests = [
    *   Effect.request(
    *     GetUserRequest({ userId: 1, department: "Engineering" }),
-   *     Effect.succeed(groupedResolver)
+   *     groupedResolver
    *   ),
    *   Effect.request(
    *     GetUserRequest({ userId: 2, department: "Engineering" }),
-   *     Effect.succeed(groupedResolver)
+   *     groupedResolver
    *   ),
    *   Effect.request(
    *     GetUserRequest({ userId: 3, department: "Marketing" }),
-   *     Effect.succeed(groupedResolver)
+   *     groupedResolver
    *   )
    * ]
    * ```
@@ -1320,7 +1300,7 @@ export const race: {
  * )
  *
  * // Spans will automatically include batch size and request links
- * const effect = Effect.request(GetDataRequest({ id: 123 }), Effect.succeed(tracedResolver))
+ * const effect = Effect.request(GetDataRequest({ id: 123 }), tracedResolver)
  * ```
  *
  * @since 4.0.0
@@ -1362,7 +1342,7 @@ export const withSpan: {
    * )
    *
    * // Spans will automatically include batch size and request links
-   * const effect = Effect.request(GetDataRequest({ id: 123 }), Effect.succeed(tracedResolver))
+   * const effect = Effect.request(GetDataRequest({ id: 123 }), tracedResolver)
    * ```
    *
    * @since 4.0.0
@@ -1407,7 +1387,7 @@ export const withSpan: {
    * )
    *
    * // Spans will automatically include batch size and request links
-   * const effect = Effect.request(GetDataRequest({ id: 123 }), Effect.succeed(tracedResolver))
+   * const effect = Effect.request(GetDataRequest({ id: 123 }), tracedResolver)
    * ```
    *
    * @since 4.0.0
@@ -1431,7 +1411,7 @@ export const withSpan: {
         const links = opts?.links ? opts.links.slice() : []
         const seen = new Set<Tracer.AnySpan>()
         for (const entry of entries) {
-          const span = ServiceMap.getOption(entry.services, Tracer.ParentSpan)
+          const span = Context.getOption(entry.context, Tracer.ParentSpan)
           if (span._tag === "None" || seen.has(span.value)) continue
           seen.add(span.value)
           links.push({ span: span.value, attributes: {} })
@@ -1468,7 +1448,7 @@ export const asCache: {
   >(
     options: {
       readonly capacity: number
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly requireServicesAt?: ServiceMode | undefined
     }
   ): (self: RequestResolver<A>) => Effect.Effect<
@@ -1495,7 +1475,7 @@ export const asCache: {
     self: RequestResolver<A>,
     options: {
       readonly capacity: number
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly requireServicesAt?: ServiceMode | undefined
     }
   ): Effect.Effect<
@@ -1513,7 +1493,7 @@ export const asCache: {
   ServiceMode extends "lookup" | "construction" = never
 >(self: RequestResolver<A>, options: {
   readonly capacity: number
-  readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+  readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
   readonly requireServicesAt?: ServiceMode | undefined
 }): Effect.Effect<
   Cache.Cache<
@@ -1525,11 +1505,10 @@ export const asCache: {
   never,
   "construction" extends ServiceMode ? Request.Services<A> : never
 > =>
-  Cache.makeWith({
+  Cache.makeWith((req: A) => internal.request(req, self), {
     capacity: options.capacity,
     timeToLive: options.timeToLive as any,
-    requireServicesAt: options.requireServicesAt ?? "lookup" as ServiceMode,
-    lookup: (req: A) => internal.request(req, Effect.succeed(self))
+    requireServicesAt: options.requireServicesAt ?? "lookup" as ServiceMode
   }) as any)
 
 /**
@@ -1649,7 +1628,7 @@ export const persisted: {
   <A extends Request.Request<any, Persistence.PersistenceError | Schema.SchemaError, any> & Persistable.Any>(
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ): (self: RequestResolver<A>) => Effect.Effect<
@@ -1667,7 +1646,7 @@ export const persisted: {
     self: RequestResolver<A>,
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ): Effect.Effect<
@@ -1683,7 +1662,7 @@ export const persisted: {
     self: RequestResolver<A>,
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ) {
@@ -1696,7 +1675,7 @@ export const persisted: {
       ...self,
       runAll: Effect.fnUntraced(function*(entries, key) {
         const results = yield* (store.getMany(Iterable.map(entries, (_) => _.request)).pipe(
-          Effect.provideServices(entries[0].services)
+          Effect.provideContext(entries[0].context)
         ) as Effect.Effect<
           Array<Exit.Exit<unknown, unknown> | undefined>,
           Request.Error<A>
@@ -1732,7 +1711,7 @@ export const persisted: {
           return Effect.void
         })
         yield* (store.setMany(toPersist).pipe(
-          Effect.provideServices(entries[0].services)
+          Effect.provideContext(entries[0].context)
         ) as Effect.Effect<void, Request.Error<A>>)
       })
     });

package/src/Resource.ts

@@ -1,15 +1,16 @@
 /**
  * @since 2.0.0
  */
+import * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import { identity } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Schedule from "./Schedule.ts"
 import type * as Scope from "./Scope.ts"
 import * as ScopedRef from "./ScopedRef.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/Resource" as const
 
@@ -32,7 +33,7 @@ export interface Resource<in out A, in out E = never> extends Pipeable {
  */
 export const isResource: (u: unknown) => u is Resource<unknown, unknown> = (
   u: unknown
-): u is Resource<unknown, unknown> => typeof u === "object" && u !== null && TypeId in u
+): u is Resource<unknown, unknown> => hasProperty(u, TypeId)
 
 const Proto = {
   ...PipeInspectableProto,
@@ -63,10 +64,10 @@ const makeUnsafe = <A, E>(
 export const manual = <A, E, R>(
   acquire: Effect.Effect<A, E, R>
 ): Effect.Effect<Resource<A, E>, never, Scope.Scope | R> =>
-  Effect.servicesWith((services: ServiceMap.ServiceMap<R>) => {
-    const providedAcquire = Effect.updateServices(
+  Effect.contextWith((context: Context.Context<R>) => {
+    const providedAcquire = Effect.updateContext(
       acquire,
-      (input: ServiceMap.ServiceMap<never>) => ServiceMap.merge(services, input)
+      (input: Context.Context<never>) => Context.merge(context, input)
     )
     return Effect.map(
       ScopedRef.fromAcquire(Effect.exit(providedAcquire)),

package/src/Result.ts

@@ -83,7 +83,7 @@ import type { Predicate, Refinement } from "./Predicate.ts"
 import { isFunction } from "./Predicate.ts"
 import type { Covariant, NoInfer, NotFunction } from "./Types.ts"
 import type * as Unify from "./Unify.ts"
-import * as Gen from "./Utils.ts"
+import type * as Gen from "./Utils.ts"
 
 const TypeId = "~effect/data/Result"
 
@@ -2540,9 +2540,7 @@ export const gen: Gen.Gen<ResultTypeLambda> = (...args) => {
   const iterator = f()
   let state: IteratorResult<any> = iterator.next()
   while (!state.done) {
-    const current = Gen.isGenKind(state.value)
-      ? state.value.value
-      : state.value
+    const current = state.value
     if (isFailure(current)) {
       return current
     }

package/src/Runtime.ts

@@ -29,7 +29,7 @@
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
-import { dual } from "effect/Function"
+import { constVoid, dual } from "effect/Function"
 import type * as Fiber from "./Fiber.ts"
 
 /**
@@ -117,7 +117,9 @@ export const defaultTeardown: Teardown = <E, A>(
   exit: Exit.Exit<E, A>,
   onExit: (code: number) => void
 ) => {
-  onExit(Exit.isFailure(exit) ? Cause.hasInterruptsOnly(exit.cause) ? 130 : 1 : 0)
+  if (Exit.isSuccess(exit)) return onExit(0)
+  if (Cause.hasInterruptsOnly(exit.cause)) return onExit(130)
+  return onExit(getErrorExitCode(Cause.squash(exit.cause)))
 }
 
 /**
@@ -206,12 +208,106 @@ export const makeRunMain = (
       ? Effect.runFork(effect)
       : Effect.runFork(
         Effect.tapCause(effect, (cause) => {
-          if (Cause.hasInterruptsOnly(cause)) {
-            return Effect.void
-          }
-          return Effect.logError(cause)
+          if (Cause.hasInterruptsOnly(cause)) return Effect.void
+          const isReported = getErrorReported(Cause.squash(cause))
+          return isReported ? Effect.logError(cause) : Effect.void
         })
       )
+    try {
+      const keepAlive = globalThis.setInterval(constVoid, 2_147_483_647)
+      fiber.addObserver(() => {
+        clearInterval(keepAlive)
+      })
+    } catch {}
     const teardown = options?.teardown ?? defaultTeardown
     return f({ fiber, teardown })
   })
+
+declare global {
+  interface Error {
+    readonly [errorExitCode]?: number
+    readonly [errorReported]?: boolean
+  }
+}
+
+/**
+ * @category Exit code management
+ * @since 4.0.0
+ */
+export type errorExitCode = "~effect/Runtime/errorExitCode"
+
+/**
+ * Allows associating an exit code with an error for determining the process
+ * exit code on failure.
+ *
+ * ```ts
+ * import { Data, Effect, Runtime } from "effect"
+ * import { NodeRuntime } from "@effect/platform-node"
+ *
+ * class MyError extends Data.TaggedError("MyError") {
+ *   readonly [Runtime.errorExitCode] = 42
+ * }
+ *
+ * // If the program fails with MyError, the process will exit with code 42
+ * NodeRuntime.runMain(Effect.fail(new MyError()))
+ * ```
+ *
+ * @category Exit code management
+ * @since 4.0.0
+ */
+export const errorExitCode: errorExitCode = "~effect/Runtime/errorExitCode"
+
+/**
+ * @category Exit code management
+ * @since 4.0.0
+ */
+export const getErrorExitCode = (u: unknown): number => {
+  if (typeof u === "object" && u !== null && errorExitCode in u) {
+    const code = u[errorExitCode]
+    if (typeof code === "number") {
+      return code
+    }
+  }
+  return 1
+}
+
+/**
+ * @category Error reporting management
+ * @since 4.0.0
+ */
+export type errorReported = "~effect/Runtime/errorReported"
+
+/**
+ * Allows an error to opt-out of error reporting.
+ *
+ * ```ts
+ * import { Data, Effect, Runtime } from "effect"
+ * import { NodeRuntime } from "@effect/platform-node"
+ *
+ * class MyError extends Data.TaggedError("MyError") {
+ *   readonly [Runtime.errorReported] = true
+ * }
+ *
+ * // If the program fails with MyError, the process will exit with code 1 but
+ * // no error will be logged.
+ * NodeRuntime.runMain(Effect.fail(new MyError()))
+ * ```
+ *
+ * @category Error reporting management
+ * @since 4.0.0
+ */
+export const errorReported: errorReported = "~effect/Runtime/errorReported"
+
+/**
+ * @category Error reporting management
+ * @since 4.0.0
+ */
+export const getErrorReported = (u: unknown): boolean => {
+  if (typeof u === "object" && u !== null && errorReported in u) {
+    const isReported = u[errorReported]
+    if (typeof isReported === "boolean") {
+      return isReported
+    }
+  }
+  return true
+}