effect 3.0.3 → 3.0.4

package/src/Option.ts

@@ -5,7 +5,7 @@ import type { Either } from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
 import type { LazyArg } from "./Function.js"
-import { constNull, constUndefined, dual, identity, isFunction } from "./Function.js"
+import { constNull, constUndefined, dual, identity, isFunction, pipe } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import type { Inspectable } from "./Inspectable.js"
 import * as either from "./internal/either.js"
@@ -16,7 +16,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import type { Covariant, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
-import * as Gen from "./Utils.js"
+import type * as Gen from "./Utils.js"
 
 /**
  * @category models
@@ -1261,26 +1261,24 @@ export const bind: {
  */
 export const Do: Option<{}> = some({})
 
-const adapter = Gen.adapter<OptionTypeLambda>()
-
 /**
  * @category generators
  * @since 2.0.0
  */
 export const gen: Gen.Gen<OptionTypeLambda, Gen.Adapter<OptionTypeLambda>> = (f) => {
-  const iterator = f(adapter)
+  const iterator = f(pipe)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {
     return some(state.value)
   } else {
-    let current = state.value.value
+    let current = state.value
     if (isNone(current)) {
       return current
     }
     while (!state.done) {
       state = iterator.next(current.value)
       if (!state.done) {
-        current = state.value.value
+        current = state.value
         if (isNone(current)) {
           return current
         }

package/src/Order.ts

@@ -1,4 +1,19 @@
 /**
+ * This module provides an implementation of the `Order` type class which is used to define a total ordering on some type `A`.
+ * An order is defined by a relation `<=`, which obeys the following laws:
+ *
+ * - either `x <= y` or `y <= x` (totality)
+ * - if `x <= y` and `y <= x`, then `x == y` (antisymmetry)
+ * - if `x <= y` and `y <= z`, then `x <= z` (transitivity)
+ *
+ * The truth table for compare is defined as follows:
+ *
+ * | `x <= y` | `x >= y` | Ordering |                       |
+ * | -------- | -------- | -------- | --------------------- |
+ * | `true`   | `true`   | `0`      | corresponds to x == y |
+ * | `true`   | `false`  | `< 0`    | corresponds to x < y  |
+ * | `false`  | `true`   | `> 0`    | corresponds to x > y  |
+ *
  * @since 2.0.0
  */
 import { dual } from "./Function.js"

package/src/STM.ts

@@ -72,6 +72,7 @@ export interface STM<out A, out E = never, out R = never>
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: STMUnify<this>
   [Unify.ignoreSymbol]?: STMUnifyIgnore
+  [Symbol.iterator](): Effect.EffectGenerator<STM<A, E, R>>
 }
 
 /**
@@ -149,18 +150,6 @@ export declare namespace STM {
   }
 }
 
-/**
- * @category models
- * @since 2.0.0
- */
-export interface STMGen<out A, out E, out R> {
-  readonly _A: () => A
-  readonly _E: () => E
-  readonly _R: () => R
-  readonly value: STM<A, E, R>
-  [Symbol.iterator](): Generator<STMGen<A, E, R>, A>
-}
-
 /**
  * Returns `true` if the provided value is an `STM`, `false` otherwise.
  *
@@ -810,17 +799,17 @@ export const fromOption: <A>(option: Option.Option<A>) => STM<A, Option.Option<n
  * @category models
  */
 export interface Adapter {
-  <A, E, R>(self: STM<A, E, R>): STMGen<A, E, R>
-  <A, _R, _E, _A>(a: A, ab: (a: A) => STM<_A, _E, _R>): STMGen<_A, _E, _R>
-  <A, B, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => STM<_A, _E, _R>): STMGen<_A, _E, _R>
-  <A, B, C, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => STM<_A, _E, _R>): STMGen<_A, _E, _R>
+  <A, E, R>(self: STM<A, E, R>): STM<A, E, R>
+  <A, _R, _E, _A>(a: A, ab: (a: A) => STM<_A, _E, _R>): STM<_A, _E, _R>
+  <A, B, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => STM<_A, _E, _R>): STM<_A, _E, _R>
+  <A, B, C, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => STM<_A, _E, _R>): STM<_A, _E, _R>
   <A, B, C, D, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
     bc: (b: B) => C,
     cd: (c: C) => D,
     de: (d: D) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -828,7 +817,7 @@ export interface Adapter {
     cd: (c: C) => D,
     de: (d: D) => E,
     ef: (e: E) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -837,7 +826,7 @@ export interface Adapter {
     de: (d: D) => E,
     ef: (e: E) => F,
     fg: (f: F) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -847,7 +836,7 @@ export interface Adapter {
     ef: (e: E) => F,
     fg: (f: F) => G,
     gh: (g: F) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -858,7 +847,7 @@ export interface Adapter {
     fg: (f: F) => G,
     gh: (g: G) => H,
     hi: (g: H) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -870,7 +859,7 @@ export interface Adapter {
     gh: (g: G) => H,
     hi: (h: H) => I,
     ij: (i: I) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -883,7 +872,7 @@ export interface Adapter {
     hi: (h: H) => I,
     ij: (i: I) => J,
     jk: (j: J) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -897,7 +886,7 @@ export interface Adapter {
     ij: (i: I) => J,
     jk: (j: J) => K,
     kl: (k: K) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -912,7 +901,7 @@ export interface Adapter {
     jk: (j: J) => K,
     kl: (k: K) => L,
     lm: (l: L) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -928,7 +917,7 @@ export interface Adapter {
     kl: (k: K) => L,
     lm: (l: L) => M,
     mn: (m: M) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -945,7 +934,7 @@ export interface Adapter {
     lm: (l: L) => M,
     mn: (m: M) => N,
     no: (n: N) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -963,7 +952,7 @@ export interface Adapter {
     mn: (m: M) => N,
     no: (n: N) => O,
     op: (o: O) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -982,7 +971,7 @@ export interface Adapter {
     no: (n: N) => O,
     op: (o: O) => P,
     pq: (p: P) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -1002,7 +991,7 @@ export interface Adapter {
     op: (o: O) => P,
     pq: (p: P) => Q,
     qr: (q: Q) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -1023,7 +1012,7 @@ export interface Adapter {
     pq: (p: P) => Q,
     qr: (q: Q) => R,
     rs: (r: R) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -1045,7 +1034,7 @@ export interface Adapter {
     qr: (q: Q) => R,
     rs: (r: R) => S,
     st: (s: S) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _R, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -1068,19 +1057,19 @@ export interface Adapter {
     rs: (r: R) => S,
     st: (s: S) => T,
     tu: (s: T) => STM<_A, _E, _R>
-  ): STMGen<_A, _E, _R>
+  ): STM<_A, _E, _R>
 }
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const gen: <Eff extends STMGen<any, any, any>, AEff>(
+export const gen: <Eff extends STM<any, any, any>, AEff>(
   f: (resume: Adapter) => Generator<Eff, AEff, any>
 ) => STM<
   AEff,
-  [Eff] extends [never] ? never : [Eff] extends [STMGen<any, infer E, any>] ? E : never,
-  [Eff] extends [never] ? never : [Eff] extends [STMGen<any, any, infer R>] ? R : never
+  [Eff] extends [never] ? never : [Eff] extends [STM<infer _A, infer E, infer _R>] ? E : never,
+  [Eff] extends [never] ? never : [Eff] extends [STM<infer _A, infer _E, infer R>] ? R : never
 > = stm.gen
 
 /**

package/src/Utils.ts

@@ -164,18 +164,22 @@ export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
   readonly _E: Types.Covariant<E>
 }
 
+/**
+ * @category models
+ * @since 2.0.0
+ */
 /**
  * @category models
  * @since 2.0.0
  */
 export interface Gen<F extends TypeLambda, Z> {
-  <K extends Variance<F, any, any, any>, A>(
+  <K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(
     body: (resume: Z) => Generator<K, A>
   ): Kind<
     F,
-    [K] extends [Variance<F, infer R, any, any>] ? R : never,
-    [K] extends [Variance<F, any, infer O, any>] ? O : never,
-    [K] extends [Variance<F, any, any, infer E>] ? E : never,
+    [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never,
+    [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never,
+    [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never,
     A
   >
 }
@@ -187,22 +191,22 @@ export interface Gen<F extends TypeLambda, Z> {
 export interface Adapter<Z extends TypeLambda> {
   <_R, _O, _E, _A>(
     self: Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
-  <A, _R, _O, _E, _A>(a: A, ab: (a: A) => Kind<Z, _R, _O, _E, _A>): GenKind<Z, _R, _O, _E, _A>
-  <A, B, _R, _O, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => Kind<Z, _R, _O, _E, _A>): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
+  <A, _R, _O, _E, _A>(a: A, ab: (a: A) => Kind<Z, _R, _O, _E, _A>): Kind<Z, _R, _O, _E, _A>
+  <A, B, _R, _O, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => Kind<Z, _R, _O, _E, _A>): Kind<Z, _R, _O, _E, _A>
   <A, B, C, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
     bc: (b: B) => C,
     cd: (c: C) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
     bc: (b: B) => C,
     cd: (c: C) => D,
     de: (d: D) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -210,7 +214,7 @@ export interface Adapter<Z extends TypeLambda> {
     cd: (c: C) => D,
     de: (d: D) => E,
     ef: (e: E) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -219,7 +223,7 @@ export interface Adapter<Z extends TypeLambda> {
     de: (d: D) => E,
     ef: (e: E) => F,
     fg: (f: F) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -229,7 +233,7 @@ export interface Adapter<Z extends TypeLambda> {
     ef: (e: E) => F,
     fg: (f: F) => G,
     gh: (g: F) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -240,7 +244,7 @@ export interface Adapter<Z extends TypeLambda> {
     fg: (f: F) => G,
     gh: (g: G) => H,
     hi: (g: H) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -252,7 +256,7 @@ export interface Adapter<Z extends TypeLambda> {
     gh: (g: G) => H,
     hi: (h: H) => I,
     ij: (i: I) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -265,7 +269,7 @@ export interface Adapter<Z extends TypeLambda> {
     hi: (h: H) => I,
     ij: (i: I) => J,
     jk: (j: J) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -279,7 +283,7 @@ export interface Adapter<Z extends TypeLambda> {
     ij: (i: I) => J,
     jk: (j: J) => K,
     kl: (k: K) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -294,7 +298,7 @@ export interface Adapter<Z extends TypeLambda> {
     jk: (j: J) => K,
     kl: (k: K) => L,
     lm: (l: L) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -310,7 +314,7 @@ export interface Adapter<Z extends TypeLambda> {
     kl: (k: K) => L,
     lm: (l: L) => M,
     mn: (m: M) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -327,7 +331,7 @@ export interface Adapter<Z extends TypeLambda> {
     lm: (l: L) => M,
     mn: (m: M) => N,
     no: (n: N) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -345,7 +349,7 @@ export interface Adapter<Z extends TypeLambda> {
     mn: (m: M) => N,
     no: (n: N) => O,
     op: (o: O) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -364,7 +368,7 @@ export interface Adapter<Z extends TypeLambda> {
     no: (n: N) => O,
     op: (o: O) => P,
     pq: (p: P) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -384,7 +388,7 @@ export interface Adapter<Z extends TypeLambda> {
     op: (o: O) => P,
     pq: (p: P) => Q,
     qr: (q: Q) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -405,7 +409,7 @@ export interface Adapter<Z extends TypeLambda> {
     pq: (p: P) => Q,
     qr: (q: Q) => R,
     rs: (r: R) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -427,7 +431,7 @@ export interface Adapter<Z extends TypeLambda> {
     qr: (q: Q) => R,
     rs: (r: R) => S,
     st: (s: S) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -450,20 +454,19 @@ export interface Adapter<Z extends TypeLambda> {
     rs: (r: R) => S,
     st: (s: S) => T,
     tu: (s: T) => Kind<Z, _R, _O, _E, _A>
-  ): GenKind<Z, _R, _O, _E, _A>
+  ): Kind<Z, _R, _O, _E, _A>
 }
 
 /**
  * @category adapters
  * @since 2.0.0
  */
-export const adapter: <F extends TypeLambda>() => Adapter<F> = () => // @ts-expect-error
-(function() {
+export const adapter: <F extends TypeLambda>() => Adapter<F> = () => (function() {
   let x = arguments[0]
   for (let i = 1; i < arguments.length; i++) {
     x = arguments[i](x)
   }
-  return new GenKindImpl(x)
+  return x
 })
 
 const defaultIncHi = 0x14057b7e

package/src/index.ts

@@ -531,6 +531,21 @@ export * as Number from "./Number.js"
 export * as Option from "./Option.js"
 
 /**
+ * This module provides an implementation of the `Order` type class which is used to define a total ordering on some type `A`.
+ * An order is defined by a relation `<=`, which obeys the following laws:
+ *
+ * - either `x <= y` or `y <= x` (totality)
+ * - if `x <= y` and `y <= x`, then `x == y` (antisymmetry)
+ * - if `x <= y` and `y <= z`, then `x <= z` (transitivity)
+ *
+ * The truth table for compare is defined as follows:
+ *
+ * | `x <= y` | `x >= y` | Ordering |                       |
+ * | -------- | -------- | -------- | --------------------- |
+ * | `true`   | `true`   | `0`      | corresponds to x == y |
+ * | `true`   | `false`  | `< 0`    | corresponds to x < y  |
+ * | `false`  | `true`   | `> 0`    | corresponds to x > y  |
+ *
  * @since 2.0.0
  */
 export * as Order from "./Order.js"

package/src/internal/core-effect.ts

@@ -34,7 +34,6 @@ import * as fiberRefsPatch from "./fiberRefs/patch.js"
 import type { FiberRuntime } from "./fiberRuntime.js"
 import * as metricLabel from "./metric/label.js"
 import * as runtimeFlags from "./runtimeFlags.js"
-import * as SingleShotGen from "./singleShotGen.js"
 import * as internalTracer from "./tracer.js"
 
 /* @internal */
@@ -774,23 +773,6 @@ export const forever = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<ne
   return loop
 }
 
-/** @internal */
-class EffectGen {
-  constructor(readonly value: Effect.Effect<any, any, any>) {
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen.SingleShotGen(this)
-  }
-}
-
-const adapter = function() {
-  let x = arguments[0]
-  for (let i = 1; i < arguments.length; i++) {
-    x = arguments[i](x)
-  }
-  return new EffectGen(x) as any
-}
-
 /**
  * Inspired by https://github.com/tusharmath/qio/pull/22 (revised)
   @internal */
@@ -802,16 +784,13 @@ export const gen: typeof Effect.gen = function() {
     f = arguments[1].bind(arguments[0])
   }
   return core.suspend(() => {
-    const iterator = f(adapter)
+    const iterator = f(pipe)
     const state = iterator.next()
     const run = (
       state: IteratorYieldResult<any> | IteratorReturnResult<any>
     ): Effect.Effect<any, any, any> => (state.done
       ? core.succeed(state.value)
-      : pipe(
-        state.value.value as unknown as Effect.Effect<any, any, any>,
-        core.flatMap((val: any) => run(iterator.next(val)))
-      ))
+      : core.flatMap(state.value, (val: any) => run(iterator.next(val))))
     return run(state)
   })
 }

package/src/internal/core.ts

@@ -47,6 +47,7 @@ import type * as fiberScope from "./fiberScope.js"
 import * as DeferredOpCodes from "./opCodes/deferred.js"
 import * as OpCodes from "./opCodes/effect.js"
 import * as _runtimeFlags from "./runtimeFlags.js"
+import { SingleShotGen } from "./singleShotGen.js"
 import * as internalTracer from "./tracer.js"
 
 // -----------------------------------------------------------------------------
@@ -178,6 +179,9 @@ class EffectPrimitive {
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
+  [Symbol.iterator]() {
+    return new SingleShotGen(this)
+  }
 }
 
 /** @internal */
@@ -216,6 +220,9 @@ class EffectPrimitiveFailure {
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
+  [Symbol.iterator]() {
+    return new SingleShotGen(this)
+  }
 }
 
 /** @internal */
@@ -254,6 +261,9 @@ class EffectPrimitiveSuccess {
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
+  [Symbol.iterator]() {
+    return new SingleShotGen(this)
+  }
 }
 
 /** @internal */

package/src/internal/effectable.ts

@@ -7,6 +7,7 @@ import { pipeArguments } from "../Pipeable.js"
 import type * as Sink from "../Sink.js"
 import type * as Stream from "../Stream.js"
 import * as OpCodes from "./opCodes/effect.js"
+import * as SingleShotGen from "./singleShotGen.js"
 import * as version from "./version.js"
 
 /** @internal */
@@ -75,6 +76,9 @@ export const EffectPrototype: Effect.Effect<never> & Equal.Equal = {
   [Hash.symbol]() {
     return Hash.cached(this, Hash.random(this))
   },
+  [Symbol.iterator]() {
+    return new SingleShotGen.SingleShotGen(this) as any
+  },
   pipe() {
     return pipeArguments(this, arguments)
   }

package/src/internal/fiberRuntime.ts

@@ -1585,7 +1585,7 @@ export const exists: {
     readonly batching?: boolean | "inherit" | undefined
   }): Effect.Effect<boolean, E, R>
 } = dual(
-  (args) => Predicate.isIterable(args[0]),
+  (args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]),
   <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
@@ -1639,7 +1639,7 @@ export const filter = dual<
     readonly negate?: boolean | undefined
   }) => Effect.Effect<Array<A>, E, R>
 >(
-  (args) => Predicate.isIterable(args[0]),
+  (args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]),
   <A, E, R>(elements: Iterable<A>, f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
@@ -2551,7 +2551,7 @@ export const reduceEffect = dual<
       readonly batching?: boolean | "inherit" | undefined
     }
   ) => Effect.Effect<Z, E | Effect.Effect.Error<Eff>, R | Effect.Effect.Context<Eff>>
->((args) => Predicate.isIterable(args[0]), <A, E, R, Z>(
+>((args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]), <A, E, R, Z>(
   elements: Iterable<Effect.Effect<A, E, R>>,
   zero: Effect.Effect<Z, E, R>,
   f: (acc: NoInfer<Z>, a: NoInfer<A>, i: number) => Z,

package/src/internal/rateLimiter.ts

@@ -34,7 +34,7 @@ const tokenBucket = (limit: number, window: DurationInput): Effect.Effect<
   Effect.gen(function*(_) {
     const millisPerToken = Math.ceil(Duration.toMillis(window) / limit)
     const semaphore = yield* _(Effect.makeSemaphore(limit))
-    const latch = yield* _(Effect.makeSemaphore(0))
+    const latch = yield* Effect.makeSemaphore(0)
     const refill: Effect.Effect<void> = Effect.sleep(millisPerToken).pipe(
       Effect.zipRight(latch.releaseAll),
       Effect.zipRight(semaphore.release(1)),

package/src/internal/stm/core.ts

@@ -19,6 +19,7 @@ import { ChannelTypeId } from "../core-stream.js"
 import { withFiberRuntime } from "../core.js"
 import { effectVariance } from "../effectable.js"
 import { OP_COMMIT } from "../opCodes/effect.js"
+import { SingleShotGen } from "../singleShotGen.js"
 import { SinkTypeId } from "../sink.js"
 import * as OpCodes from "./opCodes/stm.js"
 import * as TExitOpCodes from "./opCodes/tExit.js"
@@ -170,6 +171,9 @@ class STMPrimitive implements STM.STM<any, any, any> {
   [Hash.symbol](this: {}) {
     return Hash.cached(this, Hash.random(this))
   }
+  [Symbol.iterator]() {
+    return new SingleShotGen(this) as any
+  }
   commit(this: STM.STM<any, any, any>): Effect.Effect<any, any, any> {
     return unsafeAtomically(this, constVoid, constVoid)
   }