effect 3.10.6 → 3.10.8

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.10.6";
+let moduleVersion = "3.10.8";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.10.6",
+  "version": "3.10.8",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Context.ts

@@ -625,6 +625,16 @@ export const omit: <Services, S extends Array<ValidTagsById<Services>>>(
   internal.omit
 
 /**
+ * @example
+ * import { Context, Layer } from "effect"
+ *
+ * class MyTag extends Context.Tag("MyTag")<
+ *  MyTag,
+ *  { readonly myNum: number }
+ * >() {
+ *  static Live = Layer.succeed(this, { myNum: 108 })
+ * }
+ *
  * @since 2.0.0
  * @category constructors
  */

package/src/Effect.ts

@@ -10768,6 +10768,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
  */
@@ -10803,6 +10813,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
@@ -11037,6 +11068,7 @@ export declare namespace Service {
       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/internal/channel.ts

@@ -1711,7 +1711,7 @@ export const mergeWith = dual<
                     Effect.succeed(
                       core.flatMap(core.write(elem), () =>
                         core.flatMap(
-                          core.fromEffect(Effect.forkDaemon(pull)),
+                          core.fromEffect(Effect.forkIn(Effect.interruptible(pull), scope)),
                           (leftFiber) => go(both(leftFiber, fiber))
                         ))
                     )
@@ -1807,8 +1807,8 @@ export const mergeWith = dual<
             return pipe(
               core.fromEffect(
                 Effect.zipWith(
-                  Effect.forkIn(pullL, scope),
-                  Effect.forkIn(pullR, scope),
+                  Effect.forkIn(Effect.interruptible(pullL), scope),
+                  Effect.forkIn(Effect.interruptible(pullR), scope),
                   (left, right): State =>
                     mergeState.BothRunning<
                       Env | Env1,

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

@@ -5475,17 +5475,32 @@ export const retry = dual<
     self: Stream.Stream<A, E, R>,
     schedule: Schedule.Schedule<X, E0, R2>
   ): Stream.Stream<A, E, R | R2> =>
-    unwrap(
-      Effect.map(Schedule.driver(schedule), (driver) => {
-        const loop: Stream.Stream<A, E, R | R2> = catchAll(self, (error) =>
-          unwrap(
-            Effect.matchEffect(driver.next(error as E0), {
-              onFailure: () => Effect.fail(error),
-              onSuccess: () => Effect.succeed(pipe(loop, tap(() => driver.reset)))
-            })
-          ))
+    Schedule.driver(schedule).pipe(
+      Effect.map((driver) => {
+        const loop: Channel.Channel<
+          Chunk.Chunk<A>,
+          unknown,
+          E,
+          unknown,
+          unknown,
+          unknown,
+          R | R2
+        > = toChannel(self).pipe(
+          channel.mapOutEffect((out) => Effect.as(driver.reset, out)),
+          channel.catchAll((error) =>
+            driver.next(error as E0).pipe(
+              Effect.match({
+                onFailure: () => core.fail(error),
+                onSuccess: () => loop
+              }),
+              channel.unwrap
+            )
+          )
+        )
         return loop
-      })
+      }),
+      channel.unwrap,
+      fromChannel
     )
 )
 

package/src/internal/version.ts

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