[experiment] Improve Effects assignability after adding Symbol.iterator by replacing voids with unknown

packages/cli/src/Command.ts

@@ -435,9 +435,9 @@ export const run: {
     config: Omit<CliApp.ConstructorArgs<never>, "command">
   ): <Name extends string, R, E, A>(
     self: Command<Name, R, E, A>
-  ) => (args: ReadonlyArray<string>) => Effect<void, E | ValidationError, R | CliApp.Environment>
+  ) => (args: ReadonlyArray<string>) => Effect<unknown, E | ValidationError, R | CliApp.Environment>
   <Name extends string, R, E, A>(
     self: Command<Name, R, E, A>,
     config: Omit<CliApp.ConstructorArgs<never>, "command">
-  ): (args: ReadonlyArray<string>) => Effect<void, E | ValidationError, R | CliApp.Environment>
+  ): (args: ReadonlyArray<string>) => Effect<unknown, E | ValidationError, R | CliApp.Environment>
 } = Internal.run

packages/cli/src/internal/cliApp.ts

@@ -53,20 +53,20 @@ export const make = <A>(config: CliApp.CliApp.ConstructorArgs<A>): CliApp.CliApp
 export const run = dual<
   <R, E, A>(
     args: ReadonlyArray<string>,
-    execute: (a: A) => Effect.Effect<void, E, R>
+    execute: (a: A) => Effect.Effect<unknown, E, R>
   ) => (
     self: CliApp.CliApp<A>
-  ) => Effect.Effect<void, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment>,
+  ) => Effect.Effect<unknown, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment>,
   <R, E, A>(
     self: CliApp.CliApp<A>,
     args: ReadonlyArray<string>,
-    execute: (a: A) => Effect.Effect<void, E, R>
-  ) => Effect.Effect<void, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment>
+    execute: (a: A) => Effect.Effect<unknown, E, R>
+  ) => Effect.Effect<unknown, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment>
 >(3, <R, E, A>(
   self: CliApp.CliApp<A>,
   args: ReadonlyArray<string>,
-  execute: (a: A) => Effect.Effect<void, E, R>
-): Effect.Effect<void, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment> =>
+  execute: (a: A) => Effect.Effect<unknown, E, R>
+): Effect.Effect<unknown, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment> =>
   Effect.contextWithEffect((context: Context.Context<CliApp.CliApp.Environment>) => {
     // Attempt to parse the CliConfig from the environment, falling back to the
     // default CliConfig if none was provided
@@ -140,10 +140,10 @@ const handleBuiltInOption = <R, E, A>(
   executable: string,
   args: ReadonlyArray<string>,
   builtIn: BuiltInOptions.BuiltInOptions,
-  execute: (a: A) => Effect.Effect<void, E, R>,
+  execute: (a: A) => Effect.Effect<unknown, E, R>,
   config: CliConfig.CliConfig
 ): Effect.Effect<
-  void,
+  unknown,
   E | ValidationError.ValidationError,
   R | CliApp.CliApp.Environment | Terminal.Terminal
 > => {

packages/cli/src/internal/command.ts

@@ -542,13 +542,13 @@ export const run = dual<
     self: Command.Command<Name, R, E, A>
   ) => (
     args: ReadonlyArray<string>
-  ) => Effect.Effect<void, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment>,
+  ) => Effect.Effect<unknown, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment>,
   <Name extends string, R, E, A>(
     self: Command.Command<Name, R, E, A>,
     config: Omit<CliApp.CliApp.ConstructorArgs<never>, "command">
   ) => (
     args: ReadonlyArray<string>
-  ) => Effect.Effect<void, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment>
+  ) => Effect.Effect<unknown, E | ValidationError.ValidationError, R | CliApp.CliApp.Environment>
 >(2, (self, config) => {
   const app = InternalCliApp.make({
     ...config,

packages/cli/src/internal/commandDescriptor.ts

@@ -970,7 +970,7 @@ const traverseCommand = <S>(
       parentCommands: ReadonlyArray<string>,
       subcommands: ReadonlyArray<[string, Standard | GetUserInput]>,
       level: number
-    ): Effect.Effect<void, never, never> => {
+    ): Effect.Effect<unknown, never, never> => {
       switch (self._tag) {
         case "Standard": {
           const info: CommandInfo = {

packages/cli/src/internal/primitive.ts

@@ -476,7 +476,7 @@ const validatePathExistence = (
   path: string,
   shouldPathExist: Primitive.Primitive.PathExists,
   pathExists: boolean
-): Effect.Effect<void, string> => {
+): Effect.Effect<unknown, string> => {
   if (shouldPathExist === "no" && pathExists) {
     return Effect.fail(`Path '${path}' must not exist`)
   }
@@ -490,7 +490,7 @@ const validatePathType = (
   path: string,
   pathType: Primitive.Primitive.PathType,
   fileSystem: FileSystem.FileSystem
-): Effect.Effect<void, string> => {
+): Effect.Effect<unknown, string> => {
   switch (pathType) {
     case "file": {
       const checkIsFile = fileSystem.stat(path).pipe(

packages/cli/test/Command.test.ts

@@ -135,7 +135,7 @@ describe("Command", () => {
 // --
 
 interface Messages {
-  readonly log: (message: string) => Effect.Effect<void>
+  readonly log: (message: string) => Effect.Effect<unknown>
   readonly messages: Effect.Effect<ReadonlyArray<string>>
 }
 const Messages = Context.GenericTag<Messages>("Messages")

packages/effect/src/Cache.ts

@@ -67,7 +67,7 @@ export interface Cache<in out Key, out Value, out Error = never> extends Consume
    * by the lookup function. Additionally, `refresh` always triggers the
    * lookup function, disregarding the last `Error`.
    */
-  refresh(key: Key): Effect.Effect<void, Error>
+  refresh(key: Key): Effect.Effect<unknown, Error>
 
   /**
    * Associates the specified value with the specified key in the cache.

packages/effect/src/Console.ts

@@ -26,27 +26,27 @@ export type TypeId = typeof TypeId
  */
 export interface Console {
   readonly [TypeId]: TypeId
-  assert(condition: boolean, ...args: ReadonlyArray<any>): Effect<void>
-  readonly clear: Effect<void>
-  count(label?: string): Effect<void>
-  countReset(label?: string): Effect<void>
-  debug(...args: ReadonlyArray<any>): Effect<void>
-  dir(item: any, options?: any): Effect<void>
-  dirxml(...args: ReadonlyArray<any>): Effect<void>
-  error(...args: ReadonlyArray<any>): Effect<void>
+  assert(condition: boolean, ...args: ReadonlyArray<any>): Effect<unknown>
+  readonly clear: Effect<unknown>
+  count(label?: string): Effect<unknown>
+  countReset(label?: string): Effect<unknown>
+  debug(...args: ReadonlyArray<any>): Effect<unknown>
+  dir(item: any, options?: any): Effect<unknown>
+  dirxml(...args: ReadonlyArray<any>): Effect<unknown>
+  error(...args: ReadonlyArray<any>): Effect<unknown>
   group(options?: {
     readonly label?: string | undefined
     readonly collapsed?: boolean | undefined
-  }): Effect<void>
-  readonly groupEnd: Effect<void>
-  info(...args: ReadonlyArray<any>): Effect<void>
-  log(...args: ReadonlyArray<any>): Effect<void>
-  table(tabularData: any, properties?: ReadonlyArray<string>): Effect<void>
-  time(label?: string): Effect<void>
-  timeEnd(label?: string): Effect<void>
-  timeLog(label?: string, ...args: ReadonlyArray<any>): Effect<void>
-  trace(...args: ReadonlyArray<any>): Effect<void>
-  warn(...args: ReadonlyArray<any>): Effect<void>
+  }): Effect<unknown>
+  readonly groupEnd: Effect<unknown>
+  info(...args: ReadonlyArray<any>): Effect<unknown>
+  log(...args: ReadonlyArray<any>): Effect<unknown>
+  table(tabularData: any, properties?: ReadonlyArray<string>): Effect<unknown>
+  time(label?: string): Effect<unknown>
+  timeEnd(label?: string): Effect<unknown>
+  timeLog(label?: string, ...args: ReadonlyArray<any>): Effect<unknown>
+  trace(...args: ReadonlyArray<any>): Effect<unknown>
+  warn(...args: ReadonlyArray<any>): Effect<unknown>
   readonly unsafe: UnsafeConsole
 }
 
@@ -109,99 +109,99 @@ export const consoleWith: <A, E, R>(f: (console: Console) => Effect<A, E, R>) =>
  * @since 2.0.0
  * @category accessor
  */
-export const assert: (condition: boolean, ...args: ReadonlyArray<any>) => Effect<void> = internal.assert
+export const assert: (condition: boolean, ...args: ReadonlyArray<any>) => Effect<unknown> = internal.assert
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const clear: Effect<void> = internal.clear
+export const clear: Effect<unknown> = internal.clear
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const count: (label?: string) => Effect<void> = internal.count
+export const count: (label?: string) => Effect<unknown> = internal.count
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const countReset: (label?: string) => Effect<void> = internal.countReset
+export const countReset: (label?: string) => Effect<unknown> = internal.countReset
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const debug: (...args: ReadonlyArray<any>) => Effect<void> = internal.debug
+export const debug: (...args: ReadonlyArray<any>) => Effect<unknown> = internal.debug
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const dir: (item: any, options?: any) => Effect<void> = internal.dir
+export const dir: (item: any, options?: any) => Effect<unknown> = internal.dir
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const dirxml: (...args: ReadonlyArray<any>) => Effect<void> = internal.dirxml
+export const dirxml: (...args: ReadonlyArray<any>) => Effect<unknown> = internal.dirxml
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const error: (...args: ReadonlyArray<any>) => Effect<void> = internal.error
+export const error: (...args: ReadonlyArray<any>) => Effect<unknown> = internal.error
 
 /**
  * @since 2.0.0
  * @category accessor
  */
 export const group: (
   options?: { label?: string | undefined; collapsed?: boolean | undefined } | undefined
-) => Effect<void, never, Scope> = internal.group
+) => Effect<unknown, never, Scope> = internal.group
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const info: (...args: ReadonlyArray<any>) => Effect<void> = internal.info
+export const info: (...args: ReadonlyArray<any>) => Effect<unknown> = internal.info
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const log: (...args: ReadonlyArray<any>) => Effect<void> = internal.log
+export const log: (...args: ReadonlyArray<any>) => Effect<unknown> = internal.log
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const table: (tabularData: any, properties?: ReadonlyArray<string>) => Effect<void> = internal.table
+export const table: (tabularData: any, properties?: ReadonlyArray<string>) => Effect<unknown> = internal.table
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const time: (label?: string | undefined) => Effect<void, never, Scope> = internal.time
+export const time: (label?: string | undefined) => Effect<unknown, never, Scope> = internal.time
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const timeLog: (label?: string, ...args: ReadonlyArray<any>) => Effect<void> = internal.timeLog
+export const timeLog: (label?: string, ...args: ReadonlyArray<any>) => Effect<unknown> = internal.timeLog
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const trace: (...args: ReadonlyArray<any>) => Effect<void> = internal.trace
+export const trace: (...args: ReadonlyArray<any>) => Effect<unknown> = internal.trace
 
 /**
  * @since 2.0.0
  * @category accessor
  */
-export const warn: (...args: ReadonlyArray<any>) => Effect<void> = internal.warn
+export const warn: (...args: ReadonlyArray<any>) => Effect<unknown> = internal.warn
 
 /**
  * @since 2.0.0

packages/effect/src/Effect.ts

@@ -94,6 +94,8 @@ export interface Effect<out A, out E = never, out R = never> extends Effect.Vari
   readonly [Unify.typeSymbol]?: unknown
   readonly [Unify.unifySymbol]?: EffectUnify<this>
   readonly [Unify.ignoreSymbol]?: EffectUnifyIgnore
+
+  [Symbol.iterator](): Generator<Effect<A, E, R>, A>
 }
 
 /**
@@ -994,7 +996,7 @@ export const validateFirst: {
  * @category constructors
  */
 export const async: <A, E = never, R = never>(
-  register: (callback: (_: Effect<A, E, R>) => void, signal: AbortSignal) => void | Effect<void, never, R>,
+  register: (callback: (_: Effect<A, E, R>) => void, signal: AbortSignal) => void | Effect<unknown, never, R>,
   blockingOn?: FiberId.FiberId
 ) => Effect<A, E, R> = core.async
 
@@ -1466,7 +1468,7 @@ export const suspend: <A, E, R>(effect: LazyArg<Effect<A, E, R>>) => Effect<A, E
  */
 export const sync: <A>(evaluate: LazyArg<A>) => Effect<A> = core.sync
 
-const _void: Effect<void> = core.void
+const _void: Effect<unknown> = core.void
 export {
   /**
    * @since 2.0.0
@@ -2354,7 +2356,7 @@ export const acquireUseRelease: {
  */
 export const addFinalizer: <X, R>(
   finalizer: (exit: Exit.Exit<unknown, unknown>) => Effect<X, never, R>
-) => Effect<void, never, Scope.Scope | R> = fiberRuntime.addFinalizer
+) => Effect<unknown, never, Scope.Scope | R> = fiberRuntime.addFinalizer
 
 /**
  * Returns an effect that, if this effect _starts_ execution, then the
@@ -5005,7 +5007,7 @@ export const request: {
 export const cacheRequestResult: <A extends Request.Request<any, any>>(
   request: A,
   result: Request.Request.Result<A>
-) => Effect<void> = query.cacheRequest
+) => Effect<unknown> = query.cacheRequest
 
 /**
  * @since 2.0.0

packages/effect/src/FiberHandle.ts

@@ -259,7 +259,7 @@ export const get = <A, E>(self: FiberHandle<A, E>): Effect.Effect<Fiber.RuntimeF
  * @since 2.0.0
  * @categories combinators
  */
-export const clear = <A, E>(self: FiberHandle<A, E>): Effect.Effect<void> =>
+export const clear = <A, E>(self: FiberHandle<A, E>): Effect.Effect<unknown> =>
   Effect.uninterruptibleMask((restore) =>
     Effect.suspend(() => {
       if (self.state._tag === "Closed" || self.state.fiber === undefined) {

packages/effect/src/FiberMap.ts

@@ -338,16 +338,16 @@ export const has: {
  * @categories combinators
  */
 export const remove: {
-  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<void>
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<unknown>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<unknown>
 } = dual<
   <K>(
     key: K
-  ) => <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>,
+  ) => <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<unknown>,
   <K, A, E>(
     self: FiberMap<K, A, E>,
     key: K
-  ) => Effect.Effect<void>
+  ) => Effect.Effect<unknown>
 >(2, (self, key) =>
   Effect.suspend(() => {
     if (self.state._tag === "Closed") {
@@ -365,7 +365,7 @@ export const remove: {
  * @since 2.0.0
  * @categories combinators
  */
-export const clear = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<void> =>
+export const clear = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<unknown> =>
   Effect.suspend(() => {
     if (self.state._tag === "Closed") {
       return Effect.void

packages/effect/src/FiberSet.ts

@@ -230,7 +230,7 @@ export const add: {
  * @since 2.0.0
  * @categories combinators
  */
-export const clear = <A, E>(self: FiberSet<A, E>): Effect.Effect<void> =>
+export const clear = <A, E>(self: FiberSet<A, E>): Effect.Effect<unknown> =>
   Effect.suspend(() => {
     if (self.state._tag === "Closed") {
       return Effect.void

packages/effect/src/Metric.ts

@@ -370,15 +370,15 @@ export const snapshot: Effect.Effect<ReadonlyArray<MetricPair.MetricPair.Untyped
  * @since 2.0.0
  * @category constructors
  */
-export const succeed: <Out>(out: Out) => Metric<void, unknown, Out> = internal.succeed
+export const succeed: <Out>(out: Out) => Metric<undefined, unknown, Out> = internal.succeed
 
 /**
  * Creates a metric that ignores input and produces constant output.
  *
  * @since 2.0.0
  * @category constructors
  */
-export const sync: <Out>(evaluate: LazyArg<Out>) => Metric<void, unknown, Out> = internal.sync
+export const sync: <Out>(evaluate: LazyArg<Out>) => Metric<undefined, unknown, Out> = internal.sync
 
 /**
  * Creates a Summary metric that records observations and calculates quantiles.