effect 3.10.7 → 3.10.8

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/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/fiberRuntime.ts

@@ -1330,11 +1330,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 +1364,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/version.ts

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