effect 4.0.0-beta.65 → 4.0.0-beta.66

package/src/Effectable.ts

@@ -30,7 +30,7 @@ const Base: new<A, E, R>() => Effect.Effect<A, E, R> = (() => {
   Base.prototype = Prototype({
     label: "Effectable",
     evaluate(_) {
-      return this.asEffect()
+      return this
     }
   })
   return Base as any
@@ -43,5 +43,5 @@ const Base: new<A, E, R>() => Effect.Effect<A, E, R> = (() => {
  * @category Constructors
  */
 export abstract class Class<A, E = never, R = never> extends Base<A, E, R> {
-  abstract override asEffect(): Effect.Effect<A, E, R>
+  abstract override: Effect.Effect<A, E, R>
 }

package/src/ExecutionPlan.ts

@@ -94,10 +94,9 @@ export interface ExecutionPlan<
   }>
 
   /**
-   * Returns an equivalent `ExecutionPlan` with the requirements satisfied,
-   * using the current context.
+   * Returns an equivalent `ExecutionPlan` with the requirements satisfied, using the current context.
    */
-  readonly withRequirements: Effect.Effect<
+  readonly captureRequirements: Effect.Effect<
     ExecutionPlan<{
       provides: Config["provides"]
       input: Config["input"]
@@ -256,7 +255,7 @@ export declare namespace make {
 
 const Proto: Omit<ExecutionPlan<any>, "steps"> = {
   [TypeId]: TypeId,
-  get withRequirements() {
+  get captureRequirements() {
     const self = this as any as ExecutionPlan<any>
     return effect.contextWith((context: Context.Context<any>) =>
       effect.succeed(makeProto(self.steps.map((step) => ({

package/src/FiberHandle.ts

@@ -705,10 +705,10 @@ const runImpl = <A, E, R, XE extends E, XA extends A>(
  *   const run = yield* FiberHandle.runtime(handle)<Users>()
  *
  *   // run an effect and set the fiber in the handle
- *   run(Effect.andThen(Users.asEffect(), (_) => _.getAll))
+ *   run(Effect.andThen(Users, (_) => _.getAll))
  *
  *   // this will interrupt the previous fiber
- *   run(Effect.andThen(Users.asEffect(), (_) => _.getAll))
+ *   run(Effect.andThen(Users, (_) => _.getAll))
  * }).pipe(
  *   Effect.scoped // The fiber will be interrupted when the scope is closed
  * )

package/src/FiberMap.ts

@@ -1171,8 +1171,8 @@ const runImpl = <K, A, E, R, XE extends E, XA extends A>(
  *   const run = yield* FiberMap.runtime(map)<Users>()
  *
  *   // run some effects and add the fibers to the map
- *   run("effect-a", Effect.andThen(Users.asEffect(), (_) => _.getAll))
- *   run("effect-b", Effect.andThen(Users.asEffect(), (_) => _.getAll))
+ *   run("effect-a", Effect.andThen(Users, (_) => _.getAll))
+ *   run("effect-b", Effect.andThen(Users, (_) => _.getAll))
  * }).pipe(
  *   Effect.scoped // The fibers will be interrupted when the scope is closed
  * )

package/src/FiberSet.ts

@@ -612,7 +612,7 @@ const runImpl = <A, E, R, XE extends E, XA extends A>(
  *   const run = yield* FiberSet.runtime(set)<Users>()
  *
  *   // run some effects and add the fibers to the set
- *   run(Effect.andThen(Users.asEffect(), (_) => _.getAll))
+ *   run(Effect.andThen(Users, (_) => _.getAll))
  * }).pipe(
  *   Effect.scoped // The fibers will be interrupted when the scope is closed
  * )

package/src/Layer.ts

@@ -3077,7 +3077,7 @@ export const updateService: {
     layer: Layer<A1, E1, R1>,
     service: Context.Key<I, A>,
     f: (a: Types.NoInfer<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, f)))
 )
 
 /**

package/src/LayerMap.ts

@@ -365,10 +365,9 @@ export const Service = <Self>() =>
     Layer.provide(TagClass_.layerNoDeps, options.dependencies as any) :
     TagClass_.layerNoDeps
 
-  TagClass_.get = (key: string) => Layer.unwrap(Effect.map(TagClass_.asEffect(), (layerMap) => layerMap.get(key)))
-  TagClass_.contextEffect = (key: string) =>
-    Effect.flatMap(TagClass_.asEffect(), (layerMap) => layerMap.contextEffect(key))
-  TagClass_.invalidate = (key: string) => Effect.flatMap(TagClass_.asEffect(), (layerMap) => layerMap.invalidate(key))
+  TagClass_.get = (key: string) => Layer.unwrap(Effect.map(TagClass_, (layerMap) => layerMap.get(key)))
+  TagClass_.contextEffect = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.contextEffect(key))
+  TagClass_.invalidate = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.invalidate(key))
 
   return TagClass as any
 }

package/src/ManagedRuntime.ts

@@ -148,7 +148,7 @@ export interface ManagedRuntime<in R, out ER> {
  * async function main() {
  *   const runtime = ManagedRuntime.make(Notifications.layer)
  *   await runtime.runPromise(Effect.flatMap(
- *     Notifications.asEffect(),
+ *     Notifications,
  *     (_) => _.notify("Hello, world!")
  *   ))
  *   await runtime.dispose()

package/src/Option.ts

@@ -72,9 +72,7 @@
  * @since 2.0.0
  * @module
  */
-import type { NoSuchElementError } from "./Cause.ts"
 import * as Combiner from "./Combiner.ts"
-import type { EffectIterator, Yieldable } from "./Effect.ts"
 import * as Equal from "./Equal.ts"
 import * as Equivalence from "./Equivalence.ts"
 import type * as Filter from "./Filter.ts"
@@ -144,7 +142,6 @@ export type Option<A> = None<A> | Some<A>
  * **Behavior**
  *
  * - `_tag` is always `"None"`
- * - Yieldable in `Effect.gen` — yields `NoSuchElementError`
  * - Implements `Pipeable`, `Inspectable`, and structural equality
  *
  * @see {@link isNone} to check if an `Option` is `None`
@@ -153,18 +150,29 @@ export type Option<A> = None<A> | Some<A>
  * @category Models
  * @since 2.0.0
  */
-export interface None<out A> extends Pipeable, Inspectable, Yieldable<Option<A>, A, NoSuchElementError> {
+export interface None<out A> extends Pipeable, Inspectable {
   readonly _tag: "None"
   readonly _op: "None"
   readonly valueOrUndefined: undefined
   readonly [TypeId]: {
     readonly _A: Covariant<A>
   }
+  [Symbol.iterator](): OptionIterator<Option<A>>
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: OptionUnify<this>
   [Unify.ignoreSymbol]?: OptionUnifyIgnore
 }
 
+/**
+ * @since 4.0.0
+ * @category Models
+ */
+export interface OptionIterator<T extends Option<any>> {
+  next(
+    ...args: ReadonlyArray<any>
+  ): IteratorResult<T, Option.Value<T>>
+}
+
 /**
  * Represents the presence of a value within an {@link Option}.
  *
@@ -177,7 +185,6 @@ export interface None<out A> extends Pipeable, Inspectable, Yieldable<Option<A>,
  *
  * - `_tag` is always `"Some"`
  * - `.value` holds the contained value of type `A`
- * - Yieldable in `Effect.gen` — yields the inner value
  * - Implements `Pipeable`, `Inspectable`, and structural equality
  *
  * @see {@link isSome} to check if an `Option` is `Some`
@@ -186,7 +193,7 @@ export interface None<out A> extends Pipeable, Inspectable, Yieldable<Option<A>,
  * @category Models
  * @since 2.0.0
  */
-export interface Some<out A> extends Pipeable, Inspectable, Yieldable<Option<A>, A, NoSuchElementError> {
+export interface Some<out A> extends Pipeable, Inspectable {
   readonly _tag: "Some"
   readonly _op: "Some"
   readonly value: A
@@ -194,7 +201,7 @@ export interface Some<out A> extends Pipeable, Inspectable, Yieldable<Option<A>,
   readonly [TypeId]: {
     readonly _A: Covariant<A>
   }
-  [Symbol.iterator](): EffectIterator<Option<A>>
+  [Symbol.iterator](): OptionIterator<Option<A>>
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: OptionUnify<this>
   [Unify.ignoreSymbol]?: OptionUnifyIgnore

package/src/Result.ts

@@ -68,7 +68,6 @@
  * @since 4.0.0
  */
 
-import type { Yieldable } from "./Effect.ts"
 import * as Equivalence from "./Equivalence.ts"
 import type { LazyArg } from "./Function.ts"
 import { constNull, constUndefined, dual, identity } from "./Function.ts"
@@ -154,7 +153,7 @@ export type Result<A, E = never> = Success<A, E> | Failure<A, E>
  * @category Models
  * @since 4.0.0
  */
-export interface Failure<out A, out E> extends Pipeable, Inspectable, Yieldable<Result<A, E>, A, E> {
+export interface Failure<out A, out E> extends Pipeable, Inspectable {
   readonly _tag: "Failure"
   readonly _op: "Failure"
   readonly failure: E
@@ -162,11 +161,22 @@ export interface Failure<out A, out E> extends Pipeable, Inspectable, Yieldable<
     readonly _A: Covariant<E>
     readonly _E: Covariant<A>
   }
+  [Symbol.iterator](): ResultIterator<Result<A, E>>
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: ResultUnify<this>
   [Unify.ignoreSymbol]?: ResultUnifyIgnore
 }
 
+/**
+ * @since 4.0.0
+ * @category Models
+ */
+export interface ResultIterator<T extends Result<any, any>> {
+  next(
+    ...args: ReadonlyArray<any>
+  ): IteratorResult<T, Result.Success<T>>
+}
+
 /**
  * The success variant of {@link Result}. Wraps a value of type `A`.
  *
@@ -194,7 +204,7 @@ export interface Failure<out A, out E> extends Pipeable, Inspectable, Yieldable<
  * @category Models
  * @since 4.0.0
  */
-export interface Success<out A, out E> extends Pipeable, Inspectable, Yieldable<Result<A, E>, A, E> {
+export interface Success<out A, out E> extends Pipeable, Inspectable {
   readonly _tag: "Success"
   readonly _op: "Success"
   readonly success: A
@@ -202,6 +212,7 @@ export interface Success<out A, out E> extends Pipeable, Inspectable, Yieldable<
     readonly _A: Covariant<E>
     readonly _E: Covariant<A>
   }
+  [Symbol.iterator](): ResultIterator<Result<A, E>>
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: ResultUnify<this>
   [Unify.ignoreSymbol]?: ResultUnifyIgnore

package/src/Schedule.ts

@@ -2734,7 +2734,7 @@ export const cron: {
   (expression: string, tz?: string | DateTime.TimeZone): Schedule<Duration.Duration, unknown, Cron.CronParseError>
 } = (expression: string | Cron.Cron, tz?: string | DateTime.TimeZone) => {
   const parsed = Cron.isCron(expression) ? Result.succeed(expression) : Cron.parse(expression, tz)
-  return fromStep(effect.map(parsed.asEffect(), (cron) => (now, _) =>
+  return fromStep(effect.map(effect.fromResult(parsed), (cron) => (now, _) =>
     effect.sync(() => {
       const next = Cron.next(cron, now).getTime()
       const duration = Duration.millis(next - now)

package/src/Schema.ts

@@ -2298,10 +2298,10 @@ export declare namespace Struct {
     O extends keyof F = TypeOptionalKeys<F>,
     M extends keyof F = TypeMutableKeys<F>
   > =
-    & { readonly [K in Exclude<keyof F, M | O>]: F[K]["Type"] }
-    & { readonly [K in Exclude<O, M>]?: F[K]["Type"] }
-    & { [K in Exclude<M, O>]: F[K]["Type"] }
-    & { [K in M & O]?: F[K]["Type"] }
+    & { readonly [K in keyof F as K extends M | O ? never : K]: F[K]["Type"] }
+    & { readonly [K in keyof F as K extends O ? K extends M ? never : K : never]?: F[K]["Type"] }
+    & { -readonly [K in keyof F as K extends M ? K extends O ? never : K : never]: F[K]["Type"] }
+    & { -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Type"] }
 
   /**
    * @since 4.0.0
@@ -2313,10 +2313,10 @@ export declare namespace Struct {
     O extends keyof F = TypeOptionalKeys<F>,
     M extends keyof F = TypeMutableKeys<F>
   > =
-    & { readonly [K in Exclude<keyof F, M | O>]: F[K]["Iso"] }
-    & { readonly [K in Exclude<O, M>]?: F[K]["Iso"] }
-    & { [K in Exclude<M, O>]: F[K]["Iso"] }
-    & { [K in M & O]?: F[K]["Iso"] }
+    & { readonly [K in keyof F as K extends M | O ? never : K]: F[K]["Iso"] }
+    & { readonly [K in keyof F as K extends O ? K extends M ? never : K : never]?: F[K]["Iso"] }
+    & { -readonly [K in keyof F as K extends M ? K extends O ? never : K : never]: F[K]["Iso"] }
+    & { -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Iso"] }
 
   /**
    * @since 4.0.0
@@ -2338,10 +2338,10 @@ export declare namespace Struct {
     O extends keyof F = EncodedOptionalKeys<F>,
     M extends keyof F = EncodedMutableKeys<F>
   > =
-    & { readonly [K in Exclude<keyof F, M | O>]: F[K]["Encoded"] }
-    & { readonly [K in Exclude<O, M>]?: F[K]["Encoded"] }
-    & { [K in Exclude<M, O>]: F[K]["Encoded"] }
-    & { [K in M & O]?: F[K]["Encoded"] }
+    & { readonly [K in keyof F as K extends M | O ? never : K]: F[K]["Encoded"] }
+    & { readonly [K in keyof F as K extends O ? K extends M ? never : K : never]?: F[K]["Encoded"] }
+    & { -readonly [K in keyof F as K extends M ? K extends O ? never : K : never]: F[K]["Encoded"] }
+    & { -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Encoded"] }
 
   /**
    * @since 4.0.0
@@ -10942,13 +10942,14 @@ export const TaggedClass: {
     schema: Struct.Fields | Struct<Struct.Fields>,
     annotations?: Annotations.Declaration<any, readonly [Struct<Struct.Fields>]>
   ): any => {
+    const struct = isStruct(schema) ?
+      schema.mapFields((fields) => ({ _tag: tag(tagValue), ...fields }), {
+        unsafePreserveChecks: true
+      }) :
+      TaggedStruct(tagValue, schema)
     return Class<any, {}>(identifier ?? tagValue)(
-      isStruct(schema) ?
-        schema.mapFields((fields) => ({ _tag: tag(tagValue), ...fields }), {
-          unsafePreserveChecks: true
-        }) :
-        TaggedStruct(tagValue, schema),
-      annotations
+      struct,
+      annotations as Annotations.Declaration<any, readonly [typeof struct]>
     )
   }
 }
@@ -11186,13 +11187,14 @@ export const TaggedErrorClass: {
     schema: Struct.Fields | Struct<Struct.Fields>,
     annotations?: Annotations.Declaration<any, readonly [Struct<Struct.Fields>]>
   ): any => {
+    const struct = isStruct(schema) ?
+      schema.mapFields((fields) => ({ _tag: tag(tagValue), ...fields }), {
+        unsafePreserveChecks: true
+      }) :
+      TaggedStruct(tagValue, schema)
     return ErrorClass<any, {}>(identifier ?? tagValue)(
-      isStruct(schema) ?
-        schema.mapFields((fields) => ({ _tag: tag(tagValue), ...fields }), {
-          unsafePreserveChecks: true
-        }) :
-        TaggedStruct(tagValue, schema),
-      annotations
+      struct,
+      annotations as Annotations.Declaration<any, readonly [typeof struct]>
     )
   }
 }

package/src/SchemaGetter.ts

@@ -1291,10 +1291,10 @@ export function encodeHex<E extends Uint8Array | string>(): Getter<string, E> {
  */
 export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
-    Result.mapError(
-      Encoding.decodeBase64(input),
+    Effect.mapErrorEager(
+      Effect.fromResult(Encoding.decodeBase64(input)),
       (e) => new Issue.InvalidValue(Option.some(input), { message: e.message })
-    ).asEffect()
+    )
   )
 }
 

package/src/Stream.ts

@@ -9172,7 +9172,7 @@ export const retry: {
  *   { provide: Service.Good }
  * )
  *
- * const stream = Stream.unwrap(Effect.map(Service.asEffect(), (_) => _.stream))
+ * const stream = Stream.unwrap(Effect.map(Service, (_) => _.stream))
  *
  * const program = Effect.gen(function*() {
  *   const items = yield* stream.pipe(Stream.withExecutionPlan(plan), Stream.runCollect)
@@ -9214,7 +9214,7 @@ export const withExecutionPlan: {
    *   { provide: Service.Good }
    * )
    *
-   * const stream = Stream.unwrap(Effect.map(Service.asEffect(), (_) => _.stream))
+   * const stream = Stream.unwrap(Effect.map(Service, (_) => _.stream))
    *
    * const program = Effect.gen(function*() {
    *   const items = yield* stream.pipe(Stream.withExecutionPlan(plan), Stream.runCollect)
@@ -9259,7 +9259,7 @@ export const withExecutionPlan: {
    *   { provide: Service.Good }
    * )
    *
-   * const stream = Stream.unwrap(Effect.map(Service.asEffect(), (_) => _.stream))
+   * const stream = Stream.unwrap(Effect.map(Service, (_) => _.stream))
    *
    * const program = Effect.gen(function*() {
    *   const items = yield* stream.pipe(Stream.withExecutionPlan(plan), Stream.runCollect)
@@ -9334,7 +9334,7 @@ export const withExecutionPlan: {
      *   { provide: Service.Good }
      * )
      *
-     * const stream = Stream.unwrap(Effect.map(Service.asEffect(), (_) => _.stream))
+     * const stream = Stream.unwrap(Effect.map(Service, (_) => _.stream))
      *
      * const program = Effect.gen(function*() {
      *   const items = yield* stream.pipe(Stream.withExecutionPlan(plan), Stream.runCollect)

package/src/TxRef.ts

@@ -175,7 +175,7 @@ export const modify: {
   self: TxRef<A>,
   f: (current: A) => [returnValue: R, newValue: A]
 ): Effect.Effect<R> =>
-  Effect.Transaction.asEffect().pipe(
+  Effect.Transaction.pipe(
     Effect.flatMap((state) =>
       Effect.sync(() => {
         if (!state.journal.has(self)) {

package/src/internal/concurrency.ts

@@ -16,7 +16,7 @@ export const match = <A, E, R>(
     case "unbounded":
       return unbounded()
     case "inherit":
-      return effect.flatMap(CurrentConcurrency.asEffect(), (concurrency) =>
+      return effect.flatMap(CurrentConcurrency, (concurrency) =>
         concurrency === "unbounded"
           ? unbounded()
           : concurrency > 1
@@ -40,7 +40,7 @@ export const matchSimple = <A, E, R>(
       return concurrent()
     case "inherit":
       return effect.flatMap(
-        CurrentConcurrency.asEffect(),
+        CurrentConcurrency,
         (concurrency) =>
           concurrency === "unbounded" || concurrency > 1
             ? concurrent()

package/src/internal/core.ts

@@ -95,21 +95,6 @@ export const StructuralProto = {
   }
 }
 
-/** @internal */
-export const YieldableProto = {
-  [Symbol.iterator]() {
-    return new SingleShotGen(this) as any
-  }
-}
-
-/** @internal */
-export const YieldableErrorProto = {
-  ...YieldableProto,
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
 /** @internal */
 export const EffectProto = {
   [EffectTypeId]: effectVariance,
@@ -117,9 +102,6 @@ export const EffectProto = {
   [Symbol.iterator]() {
     return new SingleShotGen(this) as any
   },
-  asEffect(): any {
-    return this
-  },
   toJSON(this: Primitive) {
     return {
       _id: "Effect",
@@ -584,12 +566,18 @@ export const YieldableError: new(
   message?: string,
   options?: ErrorOptions
 ) => Cause.YieldableError = (function() {
-  class YieldableError extends globalThis.Error {
-    asEffect() {
+  class YieldableError extends globalThis.Error {}
+  const proto = makePrimitiveProto({
+    op: "YieldableError",
+    [evaluate]() {
       return exitFail(this)
     }
-  }
-  Object.assign(YieldableError.prototype, YieldableErrorProto)
+  })
+  delete (proto as any).toString
+  Object.assign(
+    YieldableError.prototype,
+    proto
+  )
   return YieldableError as any
 })()
 
@@ -603,13 +591,14 @@ export const Error: new<A extends Record<string, any> = {}>(
       super(args?.message, args?.cause ? { cause: args.cause } : undefined)
       if (args) {
         Object.assign(this, args)
+        // @effect-diagnostics-next-line floatingEffect:off
         Object.defineProperty(this, plainArgsSymbol, {
           value: args,
           enumerable: false
         })
       }
     }
-    toJSON() {
+    override toJSON() {
       return { ...(this as any)[plainArgsSymbol], ...this }
     }
   } as any

package/src/internal/effect.ts

@@ -892,15 +892,16 @@ export const suspend: <A, E, R>(
 })
 
 /** @internal */
-export const fromYieldable = <Self extends Effect.Yieldable.Any, A, E, R>(
-  yieldable: Effect.Yieldable<Self, A, E, R>
-): Effect.Effect<A, E, R> => yieldable.asEffect()
-
-/** @internal */
-export const fromOption: <A>(option: Option.Option<A>) => Effect.Effect<A, Cause.NoSuchElementError> = fromYieldable
+export const fromOption: <A>(option: Option.Option<A>) => Effect.Effect<A, Cause.NoSuchElementError> = Option.match({
+  onNone: () => fail(new NoSuchElementError("Effect.fromOption: Option.none")),
+  onSome: succeed
+})
 
 /** @internal */
-export const fromResult: <A, E>(result: Result.Result<A, E>) => Effect.Effect<A, E> = fromYieldable
+export const fromResult: <A, E>(result: Result.Result<A, E>) => Effect.Effect<A, E> = Result.match({
+  onFailure: fail,
+  onSuccess: succeed
+})
 
 /** @internal */
 export const fromNullishOr = <A>(value: A): Effect.Effect<NonNullable<A>, Cause.NoSuchElementError> =>
@@ -1083,7 +1084,7 @@ export const never: Effect.Effect<never> = callback<never>(constVoid)
 /** @internal */
 export const gen = <
   Self,
-  Eff extends Effect.Yieldable<any, any, any, any>,
+  Eff extends Effect.Effect<any, any, any>,
   AEff
 >(
   ...args:
@@ -1092,10 +1093,10 @@ export const gen = <
 ): Effect.Effect<
   AEff,
   [Eff] extends [never] ? never
-    : [Eff] extends [Effect.Yieldable<infer _A, infer E, infer _R>] ? E
+    : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E
     : never,
   [Eff] extends [never] ? never
-    : [Eff] extends [Effect.Yieldable<infer _A, infer _E, infer R>] ? R
+    : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R
     : never
 > =>
   suspend(() =>
@@ -1223,7 +1224,7 @@ export const fnUntracedEager: Effect.fn.Untraced = (
   )
 
 const fromIteratorEagerUnsafe = (
-  evaluate: () => Iterator<Effect.Yieldable<any, any, any, any>>
+  evaluate: () => Iterator<Effect.Effect<any, any, any>>
 ): Effect.Effect<any, any, any> => {
   try {
     const iterator = evaluate()
@@ -1237,22 +1238,20 @@ const fromIteratorEagerUnsafe = (
         return succeed(state.value)
       }
 
-      const yieldable = state.value
-      const effect = yieldable.asEffect()
-      const primitive = effect as any
+      const primitive = state.value as any
 
       if (primitive && primitive._tag === "Success") {
         value = primitive.value
         continue
       } else if (primitive && primitive._tag === "Failure") {
-        return effect
+        return state.value
       } else {
         let isFirstExecution = true
 
         return suspend(() => {
           if (isFirstExecution) {
             isFirstExecution = false
-            return flatMap(effect, (value) => fromIteratorUnsafe(iterator, value))
+            return flatMap(state.value, (value) => fromIteratorUnsafe(iterator, value))
           } else {
             return suspend(() => fromIteratorUnsafe(evaluate()))
           }
@@ -1265,7 +1264,7 @@ const fromIteratorEagerUnsafe = (
 }
 
 const fromIteratorUnsafe: (
-  iterator: Iterator<Effect.Yieldable<any, any, any, any>>,
+  iterator: Iterator<Effect.Effect<any, any, any>>,
   initial?: undefined
 ) => Effect.Effect<any, any, any> = makePrimitive({
   op: "Iterator",
@@ -1275,14 +1274,13 @@ const fromIteratorUnsafe: (
     while (true) {
       const state = iter.next(value)
       if (state.done) return succeed(state.value)
-      const eff = state.value.asEffect()
-      if (!effectIsExit(eff)) {
+      if (!effectIsExit(state.value)) {
         fiber._stack.push(this)
-        return eff
-      } else if (eff._tag === "Failure") {
-        return eff
+        return state.value
+      } else if (state.value._tag === "Failure") {
+        return state.value
       }
-      value = eff.value
+      value = state.value.value
     }
   },
   [evaluate](this: any, fiber: FiberImpl) {
@@ -1968,9 +1966,7 @@ export const exitFindErrorOption = <A, E>(self: Exit.Exit<A, E>): Option.Option<
 // ----------------------------------------------------------------------------
 
 /** @internal */
-export const service: {
-  <I, S>(service: Context.Key<I, S>): Effect.Effect<S, never, I>
-} = fromYieldable as any
+export const service = <I, S>(service: Context.Key<I, S>): Effect.Effect<S, never, I> => service
 
 /** @internal */
 export const serviceOption = <I, S>(
@@ -3767,7 +3763,7 @@ export const scopeMake = (finalizerStrategy?: "sequential" | "parallel"): Effect
   sync(() => scopeMakeUnsafe(finalizerStrategy))
 
 /** @internal */
-export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag.asEffect()
+export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag
 
 /** @internal */
 export const provideScope: {
@@ -5570,10 +5566,10 @@ const provideSpanStackFrame = (name: string, stack: (() => string | undefined) |
 }
 
 /** @internal */
-export const spanAnnotations: Effect.Effect<Readonly<Record<string, unknown>>> = TracerSpanAnnotations.asEffect()
+export const spanAnnotations: Effect.Effect<Readonly<Record<string, unknown>>> = TracerSpanAnnotations
 
 /** @internal */
-export const spanLinks: Effect.Effect<ReadonlyArray<Tracer.SpanLink>> = TracerSpanLinks.asEffect()
+export const spanLinks: Effect.Effect<ReadonlyArray<Tracer.SpanLink>> = TracerSpanLinks
 
 /** @internal */
 export const linkSpans: {

package/src/internal/executionPlan.ts

@@ -73,7 +73,7 @@ export const withExecutionPlan: {
             nextEffect = effect.suspend(() => {
               if (attempted) return wrapped
               attempted = true
-              return result!.asEffect()
+              return effect.fromResult(result!)
             })
             nextEffect = internalSchedule.retry(nextEffect, scheduleFromStep(step, false)!)
           } else {
@@ -87,7 +87,7 @@ export const withExecutionPlan: {
           i++
         }
       }),
-      () => result!.asEffect()
+      () => effect.fromResult(result!)
     )
   }))