Generic across forms

docs/design/assignment.md

@@ -173,127 +173,214 @@ provided for built-in types as necessary to give the semantics described above.
 ### Simple assignment
 
 ```
+package Core;
+
 // Simple `=`.
-interface AssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface AssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint AssignWith(U:! type) {
+  extend require impls
+      AssignWithPrimitive(form(val U));
+}
+constraint Assign {
+  extend require impls AssignWith(Self);
 }
-constraint Assign { extend AssignWith(Self); }
 ```
 
-Given `var x: T` and `y: U`:
-
--   The statement `x = y;` is rewritten to `x.(AssignWith(U).Op)(y);`.
+The statement `x = y;` is rewritten to
+`x.(AssignWithPrimitive(formof(y)).Op)(y);`.
 
 ### Arithmetic
 
 ```
 // Compound `+=`.
-interface AddAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface AddAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint AddAssignWith(U:! type) {
+  extend require impls
+      AddAssignWithPrimitive(form(val U));
+}
+constraint AddAssign {
+  extend require impls AddAssignWith(Self);
 }
-constraint AddAssign { extend AddAssignWith(Self); }
 ```
 
 ```
 // Compound `-=`.
-interface SubAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface SubAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint SubAssignWith(U:! type) {
+  extend require impls
+      SubAssignWithPrimitive(form(val U));
+}
+constraint SubAssign {
+  extend require impls SubAssignWith(Self);
 }
-constraint SubAssign { extend SubAssignWith(Self); }
 ```
 
 ```
 // Compound `*=`.
-interface MulAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface MulAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint MulAssignWith(U:! type) {
+  extend require impls
+      MulAssignWithPrimitive(form(val U));
+}
+constraint MulAssign {
+  extend require impls MulAssignWith(Self);
 }
-constraint MulAssign { extend MulAssignWith(Self); }
 ```
 
 ```
 // Compound `/=`.
-interface DivAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface DivAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint DivAssignWith(U:! type) {
+  extend require impls
+      DivAssignWithPrimitive(form(val U));
+}
+constraint DivAssign {
+  extend require impls DivAssignWith(Self);
 }
-constraint DivAssign { extend DivAssignWith(Self); }
 ```
 
 ```
 // Compound `%=`.
-interface ModAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface ModAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint ModAssignWith(U:! type) {
+  extend require impls
+      ModAssignWithPrimitive(form(val U));
+}
+constraint ModAssign {
+  extend require impls ModAssignWith(Self);
 }
-constraint ModAssign { extend ModAssignWith(Self); }
 ```
 
 ```
 // Increment `++`.
-interface Inc { fn Op[addr self: Self*](); }
+interface Inc { fn Op[ref self: Self](); }
 // Decrement `++`.
-interface Dec { fn Op[addr self: Self*](); }
+interface Dec { fn Op[ref self: Self](); }
 ```
 
-Given `var x: T` and `y: U`:
+These assignment statements are rewritten as follows:
 
--   The statement `x += y;` is rewritten to `x.(AddAssignWith(U).Op)(y);`.
--   The statement `x -= y;` is rewritten to `x.(SubAssignWith(U).Op)(y);`.
--   The statement `x *= y;` is rewritten to `x.(MulAssignWith(U).Op)(y);`.
--   The statement `x /= y;` is rewritten to `x.(DivAssignWith(U).Op)(y);`.
--   The statement `x %= y;` is rewritten to `x.(ModAssignWith(U).Op)(y);`.
+-   The statement `x += y;` is rewritten to
+    `x.(AddAssignWithPrimitive(formof(y)).Op)(y);`.
+-   The statement `x -= y;` is rewritten to
+    `x.(SubAssignWithPrimitive(formof(y)).Op)(y);`.
+-   The statement `x *= y;` is rewritten to
+    `x.(MulAssignWithPrimitive(formof(y)).Op)(y);`.
+-   The statement `x /= y;` is rewritten to
+    `x.(DivAssignWithPrimitive(formof(y)).Op)(y);`.
+-   The statement `x %= y;` is rewritten to
+    `x.(ModAssignWithPrimitive(formof(y)).Op)(y);`.
 -   The statement `++x;` is rewritten to `x.(Inc.Op)();`.
 -   The statement `--x;` is rewritten to `x.(Dec.Op)();`.
 
 ### Bitwise and bit-shift
 
 ```
 // Compound `&=`.
-interface BitAndAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface BitAndAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint BitAndAssignWith(U:! type) {
+  extend require impls
+      BitAndAssignWithPrimitive(form(val U));
+}
+constraint BitAndAssign {
+  extend require impls BitAndAssignWith(Self);
 }
-constraint BitAndAssign { extend BitAndAssignWith(Self); }
 ```
 
 ```
 // Compound `|=`.
-interface BitOrAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface BitOrAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint BitOrAssignWith(U:! type) {
+  extend require impls
+      BitOrAssignWithPrimitive(form(val U));
+}
+constraint BitOrAssign {
+  extend require impls BitOrAssignWith(Self);
 }
-constraint BitOrAssign { extend BitOrAssignWith(Self); }
 ```
 
 ```
 // Compound `^=`.
-interface BitXorAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface BitXorAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint BitXorAssignWith(U:! type) {
+  extend require impls
+      BitXorAssignWithPrimitive(form(val U));
+}
+constraint BitXorAssign {
+  extend require impls BitXorAssignWith(Self);
 }
-constraint BitXorAssign { extend BitXorAssignWith(Self); }
 ```
 
 ```
 // Compound `<<=`.
-interface LeftShiftAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface LeftShiftAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint LeftShiftAssignWith(U:! type) {
+  extend require impls
+      LeftShiftAssignWithPrimitive(form(val U));
+}
+constraint LeftShiftAssign {
+  extend require impls LeftShiftAssignWith(Self);
 }
-constraint LeftShiftAssign { extend LeftShiftAssignWith(Self); }
 ```
 
 ```
 // Compound `>>=`.
-interface RightShiftAssignWith(U:! type) {
-  fn Op[addr self: Self*](other: U);
+interface RightShiftAssignWithPrimitive
+    (implicit_into U:! NoRefForm) {
+  fn Op[ref self: Self](other:? U);
+}
+constraint RightShiftAssignWith(U:! type) {
+  extend require impls
+      RightShiftAssignWithPrimitive(form(val U));
+}
+constraint RightShiftAssign {
+  extend require impls
+    RightShiftAssignWith(Self);
 }
-constraint RightShiftAssign { extend RightShiftAssignWith(Self); }
 ```
 
-Given `var x: T` and `y: U`:
+These assignment statements are rewritten as follows:
 
--   The statement `x &= y;` is rewritten to `x.(BitAndAssignWith(U).Op)(y);`.
--   The statement `x |= y;` is rewritten to `x.(BitOrAssignWith(U).Op)(y);`.
--   The statement `x ^= y;` is rewritten to `x.(BitXorAssignWith(U).Op)(y);`.
+-   The statement `x &= y;` is rewritten to
+    `x.(BitAndAssignWithPrimitive(formof(y)).Op)(y);`.
+-   The statement `x |= y;` is rewritten to
+    `x.(BitOrAssignWithPrimitive(formof(y)).Op)(y);`.
+-   The statement `x ^= y;` is rewritten to
+    `x.(BitXorAssignWithPrimitive(formof(y)).Op)(y);`.
 -   The statement `x <<= y;` is rewritten to
-    `x.(LeftShiftAssignWith(U).Op)(y);`.
+    `x.(LeftShiftAssignWithPrimitive(formof(y)).Op)(y);`.
 -   The statement `x >>= y;` is rewritten to
-    `x.(RightShiftAssignWith(U).Op)(y)`;.
+    `x.(RightShiftAssignWithPrimitive(formof(y)).Op)(y)`;.
 
 Implementations of these interfaces are provided for built-in types as necessary
 to give the semantics described above.
@@ -310,9 +397,9 @@ This defaulting is accomplished by a parameterized implementation of
 ```
 impl forall [U:! type, T:! OpWith(U) where .Self impls AssignWith(.Self.Result)]
     T as OpAssignWith(U) {
-  fn Op[addr self: Self*](other: U) {
+  fn Op[ref self: Self](other: U) {
     // Here, `$` is the operator described by `OpWith`.
-    *self = *self $ other;
+    self = self $ other;
   }
 }
 ```
@@ -321,11 +408,11 @@ If a more efficient form of compound assignment is possible for a type, a more
 specific `impl` can be provided:
 
 ```
-impl like MyString as AddWith(like MyString) {
+impl anchor MyString as AddWith(anchor MyString) {
   // Allocate new memory and perform addition.
 }
 
-impl MyString as AddAssignWith(like MyString) {
+impl MyString as AddAssignWith(MyString) {
   // Reuse existing storage where possible.
 }
 ```
@@ -355,3 +442,5 @@ impl MyString as AddAssignWith(like MyString) {
     [#1191: Bitwise and shift operators](https://github.com/carbon-language/carbon-lang/pull/1191)
 -   Proposal
     [#2511: Assignment statements](https://github.com/carbon-language/carbon-lang/pull/2511)
+-   Proposal
+    [#5389: Generic across forms](https://github.com/carbon-language/carbon-lang/pull/5389)