Make MergeRight, MergeLeft and MergeRecord homomorphic (#3825)

Co-authored-by: maksim.khramtsov <maksim.khramtsov@btsdigital.kz>

.changeset/lucky-guests-suffer.md

@@ -0,0 +1,6 @@
+---
+"effect": patch
+---
+
+- Make `MergeRight`, `MergeLeft` and `MergeRecord` in `Types` module homomorphic (preserve original `readonly` and optionality modifiers)
+- `MergeRecord` now is alias for `MergeLeft`

packages/effect/dtslint/Types.ts

@@ -63,13 +63,19 @@ hole<Types.Equals<{ a: number }, { b: number }>>()
 // $ExpectType { a: number; b: number; }
 hole<Types.MergeLeft<{ a: number; b: number }, { a: string }>>()
 
+// $ExpectType { readonly a?: number; b: number; readonly c?: string; }
+hole<Types.MergeLeft<{ readonly a?: number; b: number }, { readonly c?: string }>>()
+
 // -------------------------------------------------------------------------------------
 // MergeRight
 // -------------------------------------------------------------------------------------
 
 // $ExpectType { a: string; b: number; }
 hole<Types.MergeRight<{ a: number; b: number }, { a: string }>>()
 
+// $ExpectType { readonly a?: string; b: number; }
+hole<Types.MergeRight<{ a: number; b: number }, { readonly a?: string }>>()
+
 // -------------------------------------------------------------------------------------
 // Mutable
 // -------------------------------------------------------------------------------------

packages/effect/src/Types.ts

@@ -156,11 +156,7 @@ export type Has<A, Key extends string> = (Key extends infer K ? K extends keyof
  * @since 2.0.0
  * @category models
  */
-export type MergeLeft<K, H> = Simplify<
-  {
-    [k in keyof K | keyof H]: k extends keyof K ? K[k] : k extends keyof H ? H[k] : never
-  }
->
+export type MergeLeft<Source, Target> = MergeRight<Target, Source>
 
 /**
  * Merges two object where the keys of the right object take precedence in the case of a conflict.
@@ -172,22 +168,18 @@ export type MergeLeft<K, H> = Simplify<
  * @since 2.0.0
  * @category models
  */
-export type MergeRight<K, H> = Simplify<
-  {
-    [k in keyof K | keyof H]: k extends keyof H ? H[k] : k extends keyof K ? K[k] : never
+export type MergeRight<Target, Source> = Simplify<
+  & Source
+  & {
+    [Key in keyof Target as Key extends keyof Source ? never : Key]: Target[Key]
   }
 >
 
 /**
  * @since 2.0.0
  * @category models
  */
-export type MergeRecord<K, H> = {
-  [k in keyof K | keyof H]: k extends keyof K ? K[k]
-    : k extends keyof H ? H[k]
-    : never
-} extends infer X ? X
-  : never
+export type MergeRecord<Source, Target> = MergeLeft<Source, Target>
 
 /**
  * Describes the concurrency to use when executing multiple Effect's.