effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/Request.ts

@@ -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
 }

package/src/RequestResolver.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
@@ -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<
@@ -1529,7 +1509,7 @@ export const asCache: {
     capacity: options.capacity,
     timeToLive: options.timeToLive as any,
     requireServicesAt: options.requireServicesAt ?? "lookup" as ServiceMode,
-    lookup: (req: A) => internal.request(req, Effect.succeed(self))
+    lookup: (req: A) => internal.request(req, self)
   }) as any)
 
 /**
@@ -1649,7 +1629,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 +1647,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 +1663,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
     }
   ) {

package/src/Resource.ts

@@ -6,6 +6,7 @@ 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"
@@ -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,

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
+}