effect 3.10.7 → 3.10.9

package/src/Effect.ts

@@ -1910,7 +1910,7 @@ export const gen: {
     [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer E, infer _R>>] ? E : never,
     [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect<infer _A, infer _E, infer R>>] ? R : never
   >
-} = effect.gen
+} = core.gen
 
 /**
  * @since 2.0.0
@@ -10732,6 +10732,8 @@ export declare namespace Tag {
         : k
     ]: Type[k] extends (...args: infer Args extends ReadonlyArray<any>) => Effect<infer A, infer E, infer R> ?
       (...args: Readonly<Args>) => Effect<A, E, Self | R>
+      : Type[k] extends (...args: infer Args extends ReadonlyArray<any>) => Promise<infer A> ?
+        (...args: Readonly<Args>) => Effect<A, Cause.UnknownException, Self>
       : Type[k] extends (...args: infer Args extends ReadonlyArray<any>) => infer A ?
         (...args: Readonly<Args>) => Effect<A, never, Self>
       : Type[k] extends Effect<infer A, infer E, infer R> ? Effect<A, E, Self | R>
@@ -10768,6 +10770,16 @@ const makeTagProxy = (TagClass: Context.Tag<any, any> & Record<PropertyKey, any>
 }
 
 /**
+ * @example
+ * import { Effect, Layer } from "effect"
+ *
+ * class MapTag extends Effect.Tag("MapTag")<MapTag, Map<string, string>>() {
+ *  static Live = Layer.effect(
+ *    this,
+ *    Effect.sync(() => new Map())
+ *  )
+ * }
+ *
  * @since 2.0.0
  * @category context
  */
@@ -10780,7 +10792,9 @@ export const Tag: <const Id extends string>(id: Id) => <
   & {
     use: <X>(
       body: (_: Type) => X
-    ) => X extends Effect<infer A, infer E, infer R> ? Effect<A, E, R | Self> : Effect<X, never, Self>
+    ) => [X] extends [Effect<infer A, infer E, infer R>] ? Effect<A, E, R | Self>
+      : [X] extends [PromiseLike<infer A>] ? Effect<A, Cause.UnknownException, Self>
+      : Effect<X, never, Self>
   } = (id) => () => {
     const limit = Error.stackTraceLimit
     Error.stackTraceLimit = 2
@@ -10803,6 +10817,27 @@ export const Tag: <const Id extends string>(id: Id) => <
   }
 
 /**
+ * @example
+ * import { Effect } from 'effect';
+ *
+ * class Prefix extends Effect.Service<Prefix>()("Prefix", {
+ *  sync: () => ({ prefix: "PRE" })
+ * }) {}
+ *
+ * class Logger extends Effect.Service<Logger>()("Logger", {
+ *  accessors: true,
+ *  effect: Effect.gen(function* () {
+ *    const { prefix } = yield* Prefix
+ *    return {
+ *      info: (message: string) =>
+ *        Effect.sync(() => {
+ *          console.log(`[${prefix}][${message}]`)
+ *        })
+ *    }
+ *  }),
+ *  dependencies: [Prefix.Default]
+ * }) {}
+ *
  * @since 3.9.0
  * @category context
  * @experimental might be up for breaking changes
@@ -11033,10 +11068,13 @@ export declare namespace Service {
       }
       readonly use: <X>(
         body: (_: Self) => X
-      ) => X extends Effect<infer A, infer E, infer R> ? Effect<A, E, R | Self> : Effect<X, never, Self>
+      ) => [X] extends [Effect<infer A, infer E, infer R>] ? Effect<A, E, R | Self>
+        : [X] extends [PromiseLike<infer A>] ? Effect<A, Cause.UnknownException, Self>
+        : Effect<X, never, Self>
       readonly make: (_: MakeService<Make>) => Self
     }
     & Context.Tag<Self, Self>
+    & { key: Key }
     & (MakeAccessors<Make> extends true ? Tag.Proxy<Self, MakeService<Make>> : {})
     & (MakeDeps<Make> extends never ? {
         readonly Default: Layer.Layer<Self, MakeError<Make>, MakeContext<Make>>

package/src/Schema.ts

@@ -8240,6 +8240,26 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
 
   readonly identifier: string
 
+  /**
+   * @example
+   * import { Schema } from "effect"
+   *
+   * class MyClass extends Schema.Class<MyClass>("MyClass")({
+   *  myField: Schema.String
+   * }) {
+   *  myMethod() {
+   *    return this.myField + "my"
+   *  }
+   * }
+   *
+   * class NextClass extends MyClass.extend<NextClass>("NextClass")({
+   *  nextField: Schema.Number
+   * }) {
+   *  nextMethod() {
+   *    return this.myMethod() + this.myField + this.nextField
+   *  }
+   * }
+   */
   extend<Extended = never>(identifier: string): <newFields extends Struct.Fields>(
     fields: newFields | HasFields<newFields>,
     annotations?: Annotations.Schema<Extended>
@@ -8254,6 +8274,33 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
       Proto
     >
 
+  /**
+   * @example
+   * import { Effect, Schema } from "effect"
+   *
+   * class MyClass extends Schema.Class<MyClass>("MyClass")({
+   *   myField: Schema.String
+   * }) {
+   *   myMethod() {
+   *     return this.myField + "my"
+   *   }
+   * }
+   *
+   * class NextClass extends MyClass.transformOrFail<NextClass>("NextClass")({
+   *   nextField: Schema.Number
+   * }, {
+   *   decode: (i) =>
+   *     Effect.succeed({
+   *       myField: i.myField,
+   *       nextField: i.myField.length
+   *     }),
+   *   encode: (a) => Effect.succeed({ myField: a.myField })
+   * }) {
+   *   nextMethod() {
+   *     return this.myMethod() + this.myField + this.nextField
+   *   }
+   * }
+   */
   transformOrFail<Transformed = never>(identifier: string): <
     newFields extends Struct.Fields,
     R2,
@@ -8284,6 +8331,33 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
       Proto
     >
 
+  /**
+   * @example
+   * import { Effect, Schema } from "effect"
+   *
+   * class MyClass extends Schema.Class<MyClass>("MyClass")({
+   *   myField: Schema.String
+   * }) {
+   *   myMethod() {
+   *     return this.myField + "my"
+   *   }
+   * }
+   *
+   * class NextClass extends MyClass.transformOrFailFrom<NextClass>("NextClass")({
+   *   nextField: Schema.Number
+   * }, {
+   *   decode: (i) =>
+   *     Effect.succeed({
+   *       myField: i.myField,
+   *       nextField: i.myField.length
+   *     }),
+   *   encode: (a) => Effect.succeed({ myField: a.myField })
+   * }) {
+   *   nextMethod() {
+   *     return this.myMethod() + this.myField + this.nextField
+   *   }
+   * }
+   */
   transformOrFailFrom<Transformed = never>(identifier: string): <
     newFields extends Struct.Fields,
     R2,
@@ -8334,6 +8408,17 @@ const getFieldsFromFieldsOr = <Fields extends Struct.Fields>(fieldsOr: Fields |
   isFields(fieldsOr) ? fieldsOr : getFields(fieldsOr)
 
 /**
+ * @example
+ * import { Schema } from "effect"
+ *
+ * class MyClass extends Schema.Class<MyClass>("MyClass")({
+ *  someField: Schema.String
+ * }) {
+ *  someMethod() {
+ *    return this.someField + "bar"
+ *  }
+ * }
+ *
  * @category classes
  * @since 3.10.0
  */
@@ -8383,6 +8468,13 @@ export interface TaggedClass<Self, Tag extends string, Fields extends Struct.Fie
 }
 
 /**
+ * @example
+ * import { Schema } from "effect"
+ *
+ * class MyClass extends Schema.TaggedClass<MyClass>("MyClass")("MyClass", {
+ *  a: Schema.String
+ * }) {}
+ *
  * @category classes
  * @since 3.10.0
  */
@@ -8429,6 +8521,21 @@ export interface TaggedErrorClass<Self, Tag extends string, Fields extends Struc
 }
 
 /**
+ * @example
+ * import { Schema } from "effect"
+ *
+ * class MyError extends Schema.TaggedError<MyError>("MyError")(
+ *   "MyError",
+ *   {
+ *     module: Schema.String,
+ *     method: Schema.String,
+ *     description: Schema.String
+ *   }
+ * ) {
+ *   get message(): string {
+ *     return `${this.module}.${this.method}: ${this.description}`
+ *   }
+ * }
  * @category classes
  * @since 3.10.0
  */
@@ -10153,6 +10260,15 @@ export interface TaggedRequestClass<
 }
 
 /**
+ * @example
+ * import { Schema } from "effect"
+ *
+ * class MyRequest extends Schema.TaggedRequest<MyRequest>("MyRequest")("MyRequest", {
+ *  failure: Schema.String,
+ *  success: Schema.Number,
+ *  payload: { id: Schema.String }
+ * }) {}
+ *
  * @category classes
  * @since 3.10.0
  */

package/src/TestClock.ts

@@ -436,7 +436,7 @@ export class TestClockImpl implements TestClock {
 export const live = (data: Data): Layer.Layer<TestClock, never, Annotations.TestAnnotations | Live.TestLive> =>
   layer.scoped(
     TestClock,
-    effect.gen(function*($) {
+    core.gen(function*($) {
       const live = yield* $(Live.TestLive)
       const annotations = yield* $(Annotations.TestAnnotations)
       const clockState = yield* $(core.sync(() => ref.unsafeMake(data)))

package/src/internal/config.ts

@@ -223,7 +223,7 @@ export const number = (name?: string): Config.Config<number> => {
   const config = primitive(
     "a number property",
     (text) => {
-      const result = Number.parseFloat(text)
+      const result = Number(text)
       if (Number.isNaN(result)) {
         return Either.left(
           configError.InvalidData(
@@ -243,8 +243,8 @@ export const integer = (name?: string): Config.Config<number> => {
   const config = primitive(
     "an integer property",
     (text) => {
-      const result = Number.parseInt(text, 10)
-      if (Number.isNaN(result)) {
+      const result = Number(text)
+      if (!Number.isInteger(result)) {
         return Either.left(
           configError.InvalidData(
             [],

package/src/internal/core-effect.ts

@@ -29,7 +29,6 @@ import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
 import type { Unify } from "../Unify.js"
-import { yieldWrapGet } from "../Utils.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
 import * as core from "./core.js"
@@ -794,33 +793,6 @@ export const forever = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<ne
   return loop
 }
 
-/**
- * Inspired by https://github.com/tusharmath/qio/pull/22 (revised)
-  @internal */
-export const gen: typeof Effect.gen = function() {
-  let f: any
-  if (arguments.length === 1) {
-    f = arguments[0]
-  } else {
-    f = arguments[1].bind(arguments[0])
-  }
-  return core.suspend(() => {
-    const iterator = f(pipe)
-    const state = internalCall(() => iterator.next())
-    const run = (
-      state: IteratorYieldResult<any> | IteratorReturnResult<any>
-    ): Effect.Effect<any, any, any> => {
-      return (state.done
-        ? core.succeed(state.value)
-        : core.flatMap(
-          yieldWrapGet(state.value) as any,
-          (val: any) => run(internalCall(() => iterator.next(val)))
-        ))
-    }
-    return run(state)
-  })
-}
-
 /* @internal */
 export const fiberRefs: Effect.Effect<FiberRefs.FiberRefs> = core.withFiberRuntime((state) =>
   core.succeed(state.getFiberRefs())

package/src/internal/core.ts

@@ -122,6 +122,7 @@ export type Primitive =
   | Sync
   | UpdateRuntimeFlags
   | While
+  | FromIterator
   | WithRuntime
   | Yield
   | OpTag
@@ -137,6 +138,7 @@ export type Continuation =
   | OnSuccessAndFailure
   | OnFailure
   | While
+  | FromIterator
   | RevertFlags
 
 /** @internal */
@@ -387,6 +389,13 @@ export interface While extends
   }>
 {}
 
+/** @internal */
+export interface FromIterator extends
+  Op<OpCodes.OP_ITERATOR, {
+    effect_instruction_i0: Iterator<YieldWrap<Primitive>, any>
+  }>
+{}
+
 /** @internal */
 export interface WithRuntime extends
   Op<OpCodes.OP_WITH_RUNTIME, {
@@ -435,7 +444,7 @@ export const acquireUseRelease: {
               onFailure: (cause) => {
                 switch (exit._tag) {
                   case OpCodes.OP_FAILURE:
-                    return failCause(internalCause.parallel(exit.effect_instruction_i0, cause))
+                    return failCause(internalCause.sequential(exit.effect_instruction_i0, cause))
                   case OpCodes.OP_SUCCESS:
                     return failCause(cause)
                 }
@@ -1212,8 +1221,11 @@ export const succeed = <A>(value: A): Effect.Effect<A> => {
 }
 
 /* @internal */
-export const suspend = <A, E, R>(effect: LazyArg<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R> =>
-  flatMap(sync(effect), identity)
+export const suspend = <A, E, R>(evaluate: LazyArg<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R> => {
+  const effect = new EffectPrimitive(OpCodes.OP_COMMIT) as any
+  effect.commit = evaluate
+  return effect
+}
 
 /* @internal */
 export const sync = <A>(thunk: LazyArg<A>): Effect.Effect<A> => {
@@ -1404,6 +1416,16 @@ export const whileLoop = <A, E, R>(
   return effect
 }
 
+/* @internal */
+export const gen: typeof Effect.gen = function() {
+  const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0])
+  return suspend(() => {
+    const effect = new EffectPrimitive(OpCodes.OP_ITERATOR) as any
+    effect.effect_instruction_i0 = f(pipe)
+    return effect
+  })
+}
+
 /* @internal */
 export const withConcurrency = dual<
   (concurrency: number | "unbounded") => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,

package/src/internal/fiberRuntime.ts

@@ -1,4 +1,4 @@
-import { internalCall } from "effect/Utils"
+import { internalCall, yieldWrapGet } from "effect/Utils"
 import * as RA from "../Array.js"
 import * as Boolean from "../Boolean.js"
 import type * as Cause from "../Cause.js"
@@ -189,6 +189,16 @@ const contOpSuccess = {
     } else {
       return core.void
     }
+  },
+  [OpCodes.OP_ITERATOR]: (
+    self: FiberRuntime<any, any>,
+    cont: core.FromIterator,
+    value: unknown
+  ) => {
+    const state = internalCall(() => cont.effect_instruction_i0.next(value))
+    if (state.done) return core.exitSucceed(state.value)
+    self.pushStack(cont)
+    return yieldWrapGet(state.value)
   }
 }
 
@@ -1053,7 +1063,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
   getNextFailCont() {
     let frame = this.popStack()
     while (frame) {
-      if (frame._op !== OpCodes.OP_ON_SUCCESS && frame._op !== OpCodes.OP_WHILE) {
+      if (frame._op !== OpCodes.OP_ON_SUCCESS && frame._op !== OpCodes.OP_WHILE && frame._op !== OpCodes.OP_ITERATOR) {
         return frame
       }
       frame = this.popStack()
@@ -1299,6 +1309,10 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
     }
   }
 
+  [OpCodes.OP_ITERATOR](op: core.Primitive & { _op: OpCodes.OP_ITERATOR }) {
+    return contOpSuccess[OpCodes.OP_ITERATOR](this, op, undefined)
+  }
+
   [OpCodes.OP_COMMIT](op: core.Primitive & { _op: OpCodes.OP_COMMIT }) {
     return internalCall(() => op.commit())
   }
@@ -1330,11 +1344,6 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
         }
       }
       try {
-        if (!("_op" in cur) || !((cur as core.Primitive)._op in this)) {
-          // @ts-expect-error
-          absurd(cur)
-        }
-
         // @ts-expect-error
         cur = this.currentTracer.context(
           () => {
@@ -1369,7 +1378,9 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
             core.exitFailCause(internalCause.die(op))
         }
       } catch (e) {
-        if (core.isEffectError(e)) {
+        if (cur !== YieldedOp && !Predicate.hasProperty(cur, "_op") || !((cur as core.Primitive)._op in this)) {
+          cur = core.dieMessage(`Not a valid effect: ${Inspectable.toStringUnknown(cur)}`)
+        } else if (core.isEffectError(e)) {
           cur = core.exitFailCause(e.cause)
         } else if (core.isInterruptedException(e)) {
           cur = core.exitFailCause(

package/src/internal/opCodes/effect.ts

@@ -64,6 +64,12 @@ export type OP_WHILE = typeof OP_WHILE
 /** @internal */
 export const OP_WHILE = "While" as const
 
+/** @internal */
+export type OP_ITERATOR = typeof OP_ITERATOR
+
+/** @internal */
+export const OP_ITERATOR = "Iterator" as const
+
 /** @internal */
 export type OP_WITH_RUNTIME = typeof OP_WITH_RUNTIME
 

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.10.7"
+let moduleVersion = "3.10.9"
 
 export const getCurrentVersion = () => moduleVersion