effect 4.0.0-beta.4 → 4.0.0-beta.5

package/src/Filter.ts

@@ -7,7 +7,7 @@ import { dual } from "./Function.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
-import type { EqualsWith, ExcludeTag, ExtractTag, Tags } from "./Types.ts"
+import type { EqualsWith, ExcludeTag, ExtractReason, ExtractTag, ReasonTags, Tags } from "./Types.ts"
 
 /**
  * Represents a filter function that can transform inputs to outputs or filter them out.
@@ -456,6 +456,53 @@ const taggedImpl =
   <Input>(input: Input): Result.Result<ExtractTag<Input, Tag>, ExcludeTag<Input, Tag>> =>
     Predicate.isTagged(input, tag) ? Result.succeed(input as any) : Result.fail(input as ExcludeTag<Input, Tag>)
 
+/**
+ * Creates a filter that extracts a reason from a tagged error.
+ *
+ * @since 4.0.0
+ * @category Constructors
+ */
+export const reason: {
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <Input>(): <const Tag extends Tags<Input>, const ReasonTag extends ReasonTags<ExtractTag<Input, Tag>>>(
+    tag: Tag,
+    reasonTag: ReasonTag
+  ) => Filter<Input, ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <Input, const Tag extends Tags<Input>, const ReasonTag extends ReasonTags<ExtractTag<Input, Tag>>>(tag: Tag, reasonTag: ReasonTag): Filter<Input, ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <const Tag extends string, const ReasonTag extends string>(tag: Tag, reasonTag: ReasonTag): <Input>(input: Input) => Result.Result<ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+} = function() {
+  return arguments.length === 0 ? reasonImpl : reasonImpl(arguments[0] as any, arguments[1] as any)
+} as any
+
+const reasonImpl =
+  <const Tag extends string, const ReasonTag extends string>(tag: Tag, reasonTag: ReasonTag) =>
+  <Input>(input: Input): Result.Result<ExtractTag<Input, Tag>, ExcludeTag<Input, Tag>> => {
+    if (
+      Predicate.isTagged(input, tag) && Predicate.hasProperty(input, "reason") &&
+      Predicate.isTagged(input.reason, reasonTag)
+    ) {
+      return Result.succeed(input.reason as any)
+    }
+    return Result.fail(input as any)
+  }
+
 /**
  * Creates a filter that only passes values equal to the specified value using structural equality.
  *

package/src/PlatformError.ts

@@ -27,7 +27,7 @@ export class BadArgument extends Data.TaggedError("BadArgument")<{
  * @since 4.0.0
  * @category Model
  */
-export type SystemErrorKind =
+export type SystemErrorTag =
   | "AlreadyExists"
   | "BadResource"
   | "Busy"
@@ -44,8 +44,8 @@ export type SystemErrorKind =
  * @since 4.0.0
  * @category models
  */
-export class SystemError extends Data.TaggedError("SystemError")<{
-  kind: SystemErrorKind
+export class SystemError extends Data.Error<{
+  _tag: SystemErrorTag
   module: string
   method: string
   description?: string | undefined
@@ -57,7 +57,7 @@ export class SystemError extends Data.TaggedError("SystemError")<{
    * @since 4.0.0
    */
   override get message(): string {
-    return `${this.kind}: ${this.module}.${this.method}${
+    return `${this._tag}: ${this.module}.${this.method}${
       this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""
     }${this.description ? `: ${this.description}` : ""}`
   }
@@ -93,7 +93,7 @@ export class PlatformError extends Data.TaggedError("PlatformError")<{
  * @category constructors
  */
 export const systemError = (options: {
-  readonly kind: SystemErrorKind
+  readonly _tag: SystemErrorTag
   readonly module: string
   readonly method: string
   readonly description?: string | undefined

package/src/Types.ts

@@ -205,7 +205,7 @@ export type ExcludeTag<E, K extends string> = Exclude<E, { readonly _tag: K }>
  * @category types
  * @since 2.0.0
  */
-export type ExtractTag<E, K extends string> = Extract<E, { readonly _tag: K }>
+export type ExtractTag<E, K extends string> = E extends { readonly _tag: infer T } ? K extends T ? E : never : never
 
 /**
  * Transforms a union type into an intersection type.
@@ -914,7 +914,8 @@ export type ReasonTags<E> = E extends { readonly reason: { readonly _tag: string
  * @category types
  */
 export type ExtractReason<E, K extends string> = E extends { readonly reason: infer R }
-  ? Extract<R, { readonly _tag: K }>
+  ? R extends { readonly _tag: infer T } ? K extends T ? R : never
+  : never
   : never
 
 /**

package/src/unstable/persistence/KeyValueStore.ts

@@ -312,7 +312,7 @@ export const layerFileSystem = (
           fs.readFileString(keyPath(key)),
           "PlatformError",
           (cause) =>
-            cause.reason._tag === "SystemError" && cause.reason.kind === "NotFound" ? Effect.undefined : Effect.fail(
+            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
               new KeyValueStoreError({
                 method: "get",
                 key,
@@ -326,7 +326,7 @@ export const layerFileSystem = (
           fs.readFile(keyPath(key)),
           "PlatformError",
           (cause) =>
-            cause.reason._tag === "SystemError" && cause.reason.kind === "NotFound" ? Effect.undefined : Effect.fail(
+            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
               new KeyValueStoreError({
                 method: "getUint8Array",
                 key,

package/src/unstable/reactivity/Atom.ts

@@ -2291,16 +2291,18 @@ export const serializable: {
 } = dual(2, <R extends Atom<any>, A, I>(self: R, options: {
   readonly key: string
   readonly schema: Schema.Codec<A, I>
-}): R & Serializable<any> =>
-  Object.assign(Object.create(Object.getPrototypeOf(self)), {
+}): R & Serializable<any> => {
+  const codecJson = Schema.toCodecJson(options.schema)
+  return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
     label: self.label ?? [options.key, new Error().stack?.split("\n")[5] ?? ""],
     [SerializableTypeId]: {
       key: options.key,
-      encode: Schema.encodeSync(options.schema),
-      decode: Schema.decodeSync(options.schema)
+      encode: Schema.encodeSync(codecJson),
+      decode: Schema.decodeSync(codecJson)
     }
-  }))
+  })
+})
 
 /**
  * @since 4.0.0

package/src/unstable/reactivity/Hydration.ts

@@ -0,0 +1,112 @@
+/**
+ * @since 4.0.0
+ */
+import * as AsyncResult from "./AsyncResult.ts"
+import * as Atom from "./Atom.ts"
+import type * as AtomRegistry from "./AtomRegistry.ts"
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface DehydratedAtom {
+  readonly "~effect/reactivity/DehydratedAtom": true
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface DehydratedAtomValue extends DehydratedAtom {
+  readonly key: string
+  readonly value: unknown
+  readonly dehydratedAt: number
+  readonly resultPromise?: Promise<unknown> | undefined
+}
+
+/**
+ * @since 4.0.0
+ * @category dehydration
+ */
+export const dehydrate = (
+  registry: AtomRegistry.AtomRegistry,
+  options?: {
+    /**
+     * How to encode `AsyncResult.Initial` values. Default is "ignore".
+     */
+    readonly encodeInitialAs?: "ignore" | "promise" | "value-only" | undefined
+  }
+): Array<DehydratedAtom> => {
+  const encodeInitialResultMode = options?.encodeInitialAs ?? "ignore"
+  const arr: Array<DehydratedAtomValue> = []
+  const now = Date.now()
+  registry.getNodes().forEach((node, key) => {
+    if (!Atom.isSerializable(node.atom)) return
+    const atom = node.atom
+    const value = node.value()
+    const isInitial = AsyncResult.isAsyncResult(value) && AsyncResult.isInitial(value)
+    if (encodeInitialResultMode === "ignore" && isInitial) return
+    const encodedValue = atom[Atom.SerializableTypeId].encode(value)
+
+    // Create a promise that resolves when the atom moves out of Initial state
+    let resultPromise: Promise<unknown> | undefined
+    if (encodeInitialResultMode === "promise" && isInitial) {
+      resultPromise = new Promise((resolve) => {
+        const unsubscribe = registry.subscribe(atom, (newValue) => {
+          if (AsyncResult.isAsyncResult(newValue) && !AsyncResult.isInitial(newValue)) {
+            resolve(atom[Atom.SerializableTypeId].encode(newValue))
+            unsubscribe()
+          }
+        })
+      })
+    }
+
+    arr.push({
+      "~effect/reactivity/DehydratedAtom": true,
+      key: key as string,
+      value: encodedValue,
+      dehydratedAt: now,
+      resultPromise
+    })
+  })
+  return arr as any
+}
+
+/**
+ * @since 4.0.0
+ * @category dehydration
+ */
+export const toValues = (state: ReadonlyArray<DehydratedAtom>): Array<DehydratedAtomValue> => state as any
+
+/**
+ * @since 4.0.0
+ * @category hydration
+ */
+export const hydrate = (
+  registry: AtomRegistry.AtomRegistry,
+  dehydratedState: Iterable<DehydratedAtom>
+): void => {
+  for (const datom of (dehydratedState as Iterable<DehydratedAtomValue>)) {
+    registry.setSerializable(datom.key, datom.value)
+
+    // If there's a resultPromise, it means this was in Initial state when dehydrated
+    // and we should wait for it to resolve to a non-Initial state, then update the registry
+    if (!datom.resultPromise) continue
+    datom.resultPromise.then((resolvedValue) => {
+      // Try to update the existing node directly instead of using setSerializable
+      const nodes = registry.getNodes()
+      const node = nodes.get(datom.key)
+      if (node) {
+        // Decode the resolved value using the node's atom serializable decoder
+        const atom = node.atom as any
+        if (atom[Atom.SerializableTypeId]) {
+          const decoded = atom[Atom.SerializableTypeId].decode(resolvedValue)
+          ;(node as any).setValue(decoded)
+        }
+      } else {
+        // Fallback to setSerializable if node doesn't exist yet
+        registry.setSerializable(datom.key, resolvedValue)
+      }
+    })
+  }
+}

package/src/unstable/reactivity/index.ts

@@ -29,6 +29,11 @@ export * as AtomRef from "./AtomRef.ts"
  */
 export * as AtomRegistry from "./AtomRegistry.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as Hydration from "./Hydration.ts"
+
 /**
  * @since 4.0.0
  */