effect 4.0.0-beta.102 → 4.0.0-beta.104

package/src/internal/schema/toRepresentation.ts

@@ -17,7 +17,7 @@ export function toRepresentation(
 export function toRepresentations(
   asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
 ): SchemaRepresentation.MultiDocument {
-  return lowerASTs(asts, [])
+  return fromASTs(asts)
 }
 
 type CheckRepresentationAnnotation = SchemaRepresentation.CheckRepresentationAnnotation<
@@ -28,27 +28,6 @@ function annotationsField<A>(annotations: A | undefined): { readonly annotations
   return annotations === undefined ? undefined : { annotations }
 }
 
-/** @internal */
-export function fromSchemaMultiDocument(
-  document: SchemaRepresentation.SchemaMultiDocument
-): SchemaRepresentation.MultiDocument {
-  const definitions = Object.entries(document.definitions).map(([key, schema]) => {
-    const original = schema.ast
-    const encoded = SchemaAST.getLastEncoding(original)
-    const body = SchemaAST.isSuspend(encoded) ? encoded.thunk() : encoded
-    return { key, original, encoded, body }
-  })
-  const asts = Arr.map(document.schemas, (schema) => schema.ast)
-  return lowerASTs(asts, definitions)
-}
-
-interface ExternalDefinition {
-  readonly key: string
-  readonly original: SchemaAST.AST
-  readonly encoded: SchemaAST.AST
-  readonly body: SchemaAST.AST
-}
-
 // Preserve repeated structural nodes as references without adding noise for leaf nodes.
 function isShareable(ast: SchemaAST.AST): boolean {
   return SchemaAST.isArrays(ast) ||
@@ -58,86 +37,118 @@ function isShareable(ast: SchemaAST.AST): boolean {
 
 interface ReferenceIdentifier {
   readonly identifier: string
-  readonly isFallback: boolean
+  readonly fallback?: string | undefined
 }
 
-function resolveReferenceIdentifier(ast: SchemaAST.AST): ReferenceIdentifier | undefined {
-  const identifier = InternalAnnotations.resolveIdentifier(ast)
-  if (identifier !== undefined) return { identifier, isFallback: false }
-  const fallback = InternalAnnotations.resolveIdentifierFallback(ast)
-  return fallback === undefined ? undefined : { identifier: `${fallback}JsonEncoding`, isFallback: true }
+function resolveReferenceIdentifier(
+  input: SchemaAST.AST,
+  encoded: SchemaAST.AST
+): ReferenceIdentifier | undefined {
+  const identifier = InternalAnnotations.resolveIdentifier(encoded)
+  if (identifier !== undefined) return { identifier }
+  const fallback = (encoded !== input ? InternalAnnotations.resolveIdentifier(input) : undefined) ??
+    InternalAnnotations.resolveIdentifierFallback(encoded)
+  return fallback === undefined
+    ? undefined
+    : { identifier: `${fallback}Encoded`, fallback }
 }
 
-function hasSameReferenceOwner(self: SchemaAST.AST, that: SchemaAST.AST): boolean {
-  if (self === that) return true
-  const selfKeys = Reflect.ownKeys(self)
-  const thatKeys = Reflect.ownKeys(that)
-  if (selfKeys.length !== thatKeys.length) return false
-  for (const key of selfKeys) {
-    if (key !== "context" && (self as any)[key] !== (that as any)[key]) return false
-  }
-  return true
-}
-
-function lowerASTs(
-  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>],
-  externalDefinitions: ReadonlyArray<ExternalDefinition>
+function fromASTs(
+  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
 ): SchemaRepresentation.MultiDocument {
   const references: Record<string, SchemaRepresentation.Representation> = {}
-  const referenceMap = new Map<SchemaAST.AST, string>()
-  const fallbackReferences: Array<readonly [SchemaAST.AST, string]> = []
+  const anonymousReferences = new Map<SchemaAST.AST, string>()
   const referenceOwners = new Map<string, SchemaAST.AST>()
-  const externalReferences = new Set(externalDefinitions.map((definition) => definition.key))
+  const valueIds = new Map<unknown, number>()
+  const canonicalByKey = new Map<string, SchemaAST.AST>()
+  let nextValueId = 0
+  const buildingReferences = new Set<string>()
   const visiting = new Set<SchemaAST.AST>()
   const visited = new Set<SchemaAST.AST>()
   const shared = new Set<SchemaAST.AST>()
 
-  for (const definition of externalDefinitions) {
-    referenceOwners.set(definition.key, definition.body)
-    referenceMap.set(definition.original, definition.key)
-    referenceMap.set(definition.encoded, definition.key)
-  }
-
   for (const ast of asts) visit(ast)
-  for (const definition of externalDefinitions) visit(definition.body)
 
   const representations = Arr.map(asts, (ast) => recur(ast))
 
-  for (const definition of externalDefinitions) {
-    InternalRecord.assignProperty(references, definition.key, recur(definition.body, definition.key))
-  }
-
   return { representations, references }
 
-  function generateReference(prefix: string, owner: SchemaAST.AST): string {
+  function getReference(prefix: string, owner: SchemaAST.AST, separator = "_"): string {
     let candidate = prefix
     let suffix = 0
     while (referenceOwners.has(candidate)) {
-      candidate = `${prefix}${++suffix}`
+      if (referenceOwners.get(candidate) === owner) return candidate
+      candidate = `${prefix}${separator}${++suffix}`
     }
     referenceOwners.set(candidate, owner)
     return candidate
   }
 
+  function getValueId(value: unknown): number {
+    if (typeof value === "number" && globalThis.Number.isNaN(value)) {
+      return nextValueId++
+    }
+    const found = valueIds.get(value)
+    if (found !== undefined) return found
+    const id = nextValueId++
+    valueIds.set(value, id)
+    return id
+  }
+
+  function getIdentityKey(ast: SchemaAST.AST): string {
+    let identity = ast._tag
+    for (const [key, value] of Object.entries(ast)) {
+      if (key !== "_tag" && key !== "context") identity += `:${getValueId(value)}`
+    }
+    return identity
+  }
+
+  function getCanonicalAST(ast: SchemaAST.AST): SchemaAST.AST {
+    const key = getIdentityKey(ast)
+    const canonical = canonicalByKey.get(key)
+    if (canonical === undefined) {
+      canonicalByKey.set(key, ast)
+      return ast
+    }
+    return canonical
+  }
+
+  function annotateReference(
+    ast: SchemaAST.AST,
+    referenceIdentifier: ReferenceIdentifier,
+    reference: string
+  ): SchemaAST.AST {
+    const fallback = referenceIdentifier.fallback
+    if (fallback !== undefined) {
+      return InternalAnnotations.resolveIdentifierFallback(ast) === fallback
+        ? ast
+        : SchemaAST.annotate(ast, {
+          [InternalAnnotations.IDENTIFIER_FALLBACK_KEY]: fallback
+        })
+    }
+    return reference === referenceIdentifier.identifier
+      ? ast
+      : SchemaAST.annotate(ast, { identifier: reference })
+  }
+
+  function makeReference(reference: string, ast: SchemaAST.AST): SchemaRepresentation.Reference {
+    if (!Object.hasOwn(references, reference) && !buildingReferences.has(reference)) {
+      buildingReferences.add(reference)
+      const representation = on(ast)
+      buildingReferences.delete(reference)
+      InternalRecord.assignProperty(references, reference, representation)
+    }
+    return { _tag: "Reference", $ref: reference }
+  }
+
   function visit(input: SchemaAST.AST): void {
     const ast = SchemaAST.getLastEncoding(input)
-    if (visited.has(ast)) {
-      if (isShareable(ast)) shared.add(ast)
+    const owner = getCanonicalAST(ast)
+    if (visited.has(owner)) {
+      if (isShareable(ast)) shared.add(owner)
       return
     }
-    visited.add(ast)
-    const referenceIdentifier = resolveReferenceIdentifier(ast)
-    if (referenceIdentifier !== undefined && !referenceIdentifier.isFallback) {
-      const owner = referenceOwners.get(referenceIdentifier.identifier)
-      if (owner === undefined) {
-        referenceOwners.set(referenceIdentifier.identifier, ast)
-      } else if (
-        referenceMap.get(ast) !== referenceIdentifier.identifier &&
-        !hasSameReferenceOwner(owner, ast)
-      ) {
-        throw new Error(`Duplicate identifier: ${JSON.stringify(referenceIdentifier.identifier)}`)
-      }
-    }
+    visited.add(owner)
     visitChecks(ast.checks)
     switch (ast._tag) {
       case "Declaration":
@@ -165,49 +176,35 @@ function lowerASTs(
     })
   }
 
-  function recur(
-    ast: SchemaAST.AST,
-    ownedReference?: string
-  ): SchemaRepresentation.Representation {
-    const found = referenceMap.get(ast)
-    if (found !== undefined && found !== ownedReference) {
-      return { _tag: "Reference", $ref: found }
-    }
-
-    const projected = SchemaAST.getLastEncoding(ast)
-    if (projected !== ast) {
-      return recur(projected, ownedReference)
-    }
-
-    const referenceIdentifier = ownedReference === undefined ? resolveReferenceIdentifier(ast) : undefined
+  function recur(input: SchemaAST.AST): SchemaRepresentation.Representation {
+    const ast = SchemaAST.getLastEncoding(input)
+    const owner = getCanonicalAST(ast)
+    const referenceIdentifier = resolveReferenceIdentifier(input, ast)
     if (referenceIdentifier !== undefined) {
-      const reference = getReference(referenceIdentifier, ast)
-      referenceMap.set(ast, reference)
-      if (!Object.hasOwn(references, reference) && !externalReferences.has(reference)) {
-        InternalRecord.assignProperty(references, reference, on(ast))
-      }
-      return { _tag: "Reference", $ref: reference }
+      const reference = getReference(referenceIdentifier.identifier, owner)
+      return makeReference(reference, annotateReference(ast, referenceIdentifier, reference))
     }
 
-    if (ownedReference === undefined && shared.has(ast)) {
-      const reference = generateReference(`${ast._tag}_`, ast)
-      referenceMap.set(ast, reference)
-      InternalRecord.assignProperty(references, reference, on(ast))
-      return { _tag: "Reference", $ref: reference }
+    const found = anonymousReferences.get(owner)
+    if (found !== undefined) {
+      return { _tag: "Reference", $ref: found }
     }
 
-    if (visiting.has(ast)) {
-      const reference = generateReference(`${ast._tag}_`, ast)
-      referenceMap.set(ast, reference)
-      return { _tag: "Reference", $ref: reference }
+    const isShared = shared.has(owner)
+    if (isShared || visiting.has(owner)) {
+      const reference = getReference(`${ast._tag}_`, owner, "")
+      anonymousReferences.set(owner, reference)
+      return isShared
+        ? makeReference(reference, ast)
+        : { _tag: "Reference", $ref: reference }
     }
 
-    visiting.add(ast)
+    visiting.add(owner)
     const representation = on(ast)
-    visiting.delete(ast)
+    visiting.delete(owner)
 
-    const reference = referenceMap.get(ast)
-    if (reference !== undefined && reference !== ownedReference) {
+    const reference = anonymousReferences.get(owner)
+    if (reference !== undefined) {
       InternalRecord.assignProperty(references, reference, representation)
       return { _tag: "Reference", $ref: reference }
     }
@@ -215,18 +212,6 @@ function lowerASTs(
     return representation
   }
 
-  function getReference(referenceIdentifier: ReferenceIdentifier, ast: SchemaAST.AST): string {
-    if (!referenceIdentifier.isFallback) {
-      return referenceIdentifier.identifier
-    }
-    for (const [owner, reference] of fallbackReferences) {
-      if (hasSameReferenceOwner(owner, ast)) return reference
-    }
-    const reference = generateReference(referenceIdentifier.identifier, ast)
-    fallbackReferences.push([ast, reference])
-    return reference
-  }
-
   function on(ast: SchemaAST.AST): SchemaRepresentation.Representation {
     const checks = fromChecks(ast.checks)
     switch (ast._tag) {

package/src/internal/trie.ts

@@ -42,7 +42,7 @@ const TrieProto: TR.Trie<unknown> = {
     return hash
   },
   [Equal.symbol]<V>(this: TrieImpl<V>, that: unknown): boolean {
-    if (isTrie(that)) {
+    if (isTrie(that) && size(this) === size(that)) {
       const entries = Array.from(that)
       return Array.from(this).every((itemSelf, i) => {
         const itemThat = entries[i]
@@ -103,8 +103,8 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
         const value = node.value
         if (value !== undefined) {
           const key = keyString + node.key
-          if (this.filter(key, value)) {
-            return { done: false, value: this.f(key, value) }
+          if (this.filter(key, value.value)) {
+            return { done: false, value: this.f(key, value.value) }
           }
         }
       } else {
@@ -172,7 +172,7 @@ export const insert = dual<
     key: key[0],
     count: 0
   }
-  const count = n.count + 1
+  let count = n.count + 1
   let cIndex = 0
 
   while (cIndex < key.length) {
@@ -194,7 +194,17 @@ export const insert = dual<
       }
     } else {
       if (cIndex === key.length - 1) {
-        n.value = value
+        if (n.value !== undefined) {
+          count -= 1
+        }
+        nStack[nStack.length - 1] = {
+          key: n.key,
+          count,
+          value: { value },
+          left: n.left,
+          mid: n.mid,
+          right: n.right
+        }
       } else if (n.mid === undefined) {
         dStack.push(0)
         n = { key: key[cIndex + 1], count }
@@ -403,7 +413,7 @@ export const get = dual<
         }
       } else {
         if (cIndex === key.length - 1) {
-          return Option.fromUndefinedOr(n.value)
+          return n.value === undefined ? Option.none() : Option.some(n.value.value)
         } else {
           if (n.mid === undefined) {
             return Option.none()
@@ -632,7 +642,7 @@ export const modify = dual<
     nStack[nStack.length - 1] = {
       key: updateNode.key,
       count: updateNode.count,
-      value: f(updateNode.value), // Update
+      value: { value: f(updateNode.value.value) }, // Update
       left: updateNode.left,
       mid: updateNode.mid,
       right: updateNode.right
@@ -693,10 +703,6 @@ export const longestPrefixOf = dual<
     let cIndex = 0
     while (cIndex < key.length) {
       const c = key[cIndex]
-      if (n.value !== undefined) {
-        longestPrefixNode = Option.some([key.slice(0, cIndex + 1), n.value])
-      }
-
       if (c > n.key) {
         if (n.right === undefined) {
           break
@@ -710,6 +716,9 @@ export const longestPrefixOf = dual<
           n = n.left
         }
       } else {
+        if (n.value !== undefined) {
+          longestPrefixNode = Option.some([key.slice(0, cIndex + 1), n.value.value])
+        }
         if (n.mid === undefined) {
           break
         } else {
@@ -726,7 +735,7 @@ export const longestPrefixOf = dual<
 interface Node<V> {
   key: string
   count: number
-  value?: V | undefined
+  value?: { readonly value: V } | undefined
   left?: Node<V> | undefined
   mid?: Node<V> | undefined
   right?: Node<V> | undefined

package/src/testing/FastCheck.ts

@@ -20,7 +20,7 @@
  *
  * **Example** (Checking an array reversal property)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { FastCheck } from "effect/testing"
  *
  * // Property: reverse of reverse should equal original
@@ -29,17 +29,18 @@
  *   (arr: Array<number>) => {
  *     const reversed = arr.slice().reverse()
  *     const doubleReversed = reversed.slice().reverse()
- *     return JSON.stringify(arr) === JSON.stringify(doubleReversed)
+ *     return arr.length === doubleReversed.length &&
+ *       arr.every((value, index) => value === doubleReversed[index])
  *   }
  * )
  *
  * // Run the property test
- * FastCheck.assert(reverseProp)
+ * FastCheck.assert(reverseProp, { seed: 1, numRuns: 100 }) // => undefined
  * ```
  *
  * **Example** (Checking string concatenation properties)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { FastCheck } from "effect/testing"
  *
  * // Test string concatenation properties
@@ -54,12 +55,12 @@
  *   }
  * )
  *
- * FastCheck.assert(concatProp)
+ * FastCheck.assert(concatProp, { seed: 2, numRuns: 100 }) // => undefined
  * ```
  *
  * **Example** (Generating record data for properties)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { FastCheck } from "effect/testing"
  *
  * // Generate random data for testing
@@ -80,7 +81,7 @@
  *   }
  * )
  *
- * FastCheck.assert(validPersonProp)
+ * FastCheck.assert(validPersonProp, { seed: 3, numRuns: 100 }) // => undefined
  * ```
  *
  * @category re-exports