Equivalence: return Equal.equals instead of Equivalence.strict() … (

#2185)

.changeset/moody-chicken-juggle.md

@@ -0,0 +1,5 @@
+---
+"@effect/schema": patch
+---
+
+Equivalence: return `Equal.equals` instead of `Equivalence.strict()` as default

packages/effect/src/Equal.ts

@@ -62,4 +62,4 @@ export const isEqual = (u: unknown): u is Equal => hasProperty(u, symbol)
  * @since 2.0.0
  * @category instances
  */
-export const equivalence: <A>() => Equivalence<A> = () => (self, that) => equals(self, that)
+export const equivalence: <A>() => Equivalence<A> = () => equals

packages/schema/src/Equivalence.ts

@@ -2,6 +2,7 @@
  * @since 1.0.0
  */
 
+import * as Equal from "effect/Equal"
 import * as Equivalence from "effect/Equivalence"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
@@ -78,7 +79,7 @@ const go = (ast: AST.AST): Equivalence.Equivalence<any> => {
     case "VoidKeyword":
     case "Enums":
     case "ObjectKeyword":
-      return Equivalence.strict()
+      return Equal.equals
     case "Refinement":
       return go(ast.from)
     case "Suspend": {
@@ -127,7 +128,7 @@ const go = (ast: AST.AST): Equivalence.Equivalence<any> => {
     }
     case "TypeLiteral": {
       if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
-        return Equivalence.strict()
+        return Equal.equals
       }
       const propertySignatures = ast.propertySignatures.map((ps) => go(ps.type))
       const indexSignatures = ast.indexSignatures.map((is) => go(is.type))

packages/schema/src/Schema.ts

@@ -3520,7 +3520,7 @@ export const Uint8ArrayFromSelf: Schema<Uint8Array> = declare(
     identifier: "Uint8ArrayFromSelf",
     pretty: (): Pretty.Pretty<Uint8Array> => (u8arr) => `new Uint8Array(${JSON.stringify(Array.from(u8arr))})`,
     arbitrary: (): Arbitrary<Uint8Array> => (fc) => fc.uint8Array(),
-    equivalence: (): Equivalence.Equivalence<Uint8Array> => ReadonlyArray.getEquivalence(Equivalence.strict()) as any
+    equivalence: (): Equivalence.Equivalence<Uint8Array> => ReadonlyArray.getEquivalence(Equal.equals) as any
   }
 )
 
@@ -4644,8 +4644,7 @@ export const dataFromSelf = <
     {
       description: `Data<${format(item)}>`,
       pretty: dataPretty,
-      arbitrary: dataArbitrary,
-      equivalence: () => Equal.equals
+      arbitrary: dataArbitrary
     }
   )
 }
@@ -5076,8 +5075,7 @@ export const FiberIdFromSelf: Schema<FiberId.FiberId> = declare(
   {
     identifier: "FiberIdFromSelf",
     pretty: () => fiberIdPretty,
-    arbitrary: () => fiberIdArbitrary,
-    equivalence: () => Equal.equals
+    arbitrary: () => fiberIdArbitrary
   }
 )
 
@@ -5255,8 +5253,7 @@ export const causeFromSelf = <A, I, R1, R2 = never>({ defect = unknown, error }:
     {
       description: `Cause<${format(error)}>`,
       pretty: causePretty,
-      arbitrary: causeArbitrary,
-      equivalence: () => Equal.equals
+      arbitrary: causeArbitrary
     }
   )
 }
@@ -5432,8 +5429,7 @@ export const exitFromSelf = <E, IE, RE, A, IA, RA, RD = never>({ defect = unknow
     {
       description: `Exit<${format(failure)}, ${format(success)}>`,
       pretty: exitPretty,
-      arbitrary: exitArbitrary,
-      equivalence: () => Equal.equals
+      arbitrary: exitArbitrary
     }
   )
 

packages/schema/test/Equivalence.test.ts

@@ -4,7 +4,9 @@ import * as S from "@effect/schema/Schema"
 import * as Chunk from "effect/Chunk"
 import * as Data from "effect/Data"
 import * as Either from "effect/Either"
+import * as Equal from "effect/Equal"
 import * as Equivalence from "effect/Equivalence"
+import * as Hash from "effect/Hash"
 import * as Option from "effect/Option"
 import { isUnknown } from "effect/Predicate"
 import * as fc from "fast-check"
@@ -113,14 +115,27 @@ describe("Equivalence", () => {
   })
 
   describe("declaration", () => {
-    it("should return Equivalence.strict() when an annotation exists", () => {
-      const schema = S.declare(isUnknown, {
-        arbitrary: (): A.Arbitrary<string> => (fc) => fc.string()
-      })
+    it("should return Equal.equals when an annotation doesn't exist", () => {
+      const schema = S.declare(isUnknown)
       const equivalence = E.make(schema)
-      expect(equivalence).toStrictEqual(Equivalence.strict())
+      expect(equivalence).toStrictEqual(Equal.equals)
+
+      const make = (id: number, s: string) => {
+        return {
+          [Hash.symbol]() {
+            return 0
+          },
+          [Equal.symbol](that: any) {
+            return that.id === id
+          },
+          id,
+          s
+        }
+      }
 
-      // propertyTo(schema)
+      expect(equivalence(make(1, "a"), make(1, "a"))).toBe(true)
+      expect(equivalence(make(1, "a"), make(1, "b"))).toBe(true)
+      expect(equivalence(make(1, "a"), make(2, "a"))).toBe(false)
     })
 
     it("Chunk", () => {