Changed borrow wording to reference-of

cppalliance · Oct 14, 2024 · b822b76 · b822b76
1 parent 5bee7ea
commit b822b76
Show file tree

Hide file tree

Showing 4 changed files with 4 additions and 4 deletions.
diff --git a/docs/P3444R0.html b/docs/P3444R0.html
@@ -700,7 +700,7 @@ <h2 data-number="1.1" id="exclusivity"><span class="header-section-number">1.1</
 reference can be done safely, because it doesn’t involve any
 preconditions. Function <code class="sourceCode cpp">f</code> converts a
 safe reference <code class="sourceCode cpp">x</code> to an lvalue
-reference with a dereference and borrow:
+reference with a dereference and reference-of:
 <code class="sourceCode cpp"><span class="op">&amp;*</span>x</code>.
 Going the other way is unsafe: the precondition of the
 <em>unsafe-block</em> is that the legacy references <em>do not

diff --git a/docs/draft-lifetimes.html b/docs/draft-lifetimes.html
@@ -700,7 +700,7 @@ <h2 data-number="1.1" id="exclusivity"><span class="header-section-number">1.1</
 reference can be done safely, because it doesn’t involve any
 preconditions. Function <code class="sourceCode cpp">f</code> converts a
 safe reference <code class="sourceCode cpp">x</code> to an lvalue
-reference with a dereference and borrow:
+reference with a dereference and reference-of:
 <code class="sourceCode cpp"><span class="op">&amp;*</span>x</code>.
 Going the other way is unsafe: the precondition of the
 <em>unsafe-block</em> is that the legacy references <em>do not

diff --git a/lifetimes/P3444R0.md b/lifetimes/P3444R0.md
@@ -175,7 +175,7 @@ void f(int% x, int% y) safe {
 }
 ```
 
-While safe references and legacy references are different types, they're inter-convertible. Converting a safe reference to legacy reference can be done safely, because it doesn't involve any preconditions. Function `f` converts a safe reference `x` to an lvalue reference with a dereference and borrow: `&*x`. Going the other way is unsafe: the precondition of the _unsafe-block_ is that the legacy references _do not alias_ and _do not dangle_: `%*x`.
+While safe references and legacy references are different types, they're inter-convertible. Converting a safe reference to legacy reference can be done safely, because it doesn't involve any preconditions. Function `f` converts a safe reference `x` to an lvalue reference with a dereference and reference-of: `&*x`. Going the other way is unsafe: the precondition of the _unsafe-block_ is that the legacy references _do not alias_ and _do not dangle_: `%*x`.
 
 ## Constraint rules
 

diff --git a/lifetimes/draft-lifetimes.md b/lifetimes/draft-lifetimes.md
@@ -175,7 +175,7 @@ void f(int% x, int% y) safe {
 }
 ```
 
-While safe references and legacy references are different types, they're inter-convertible. Converting a safe reference to legacy reference can be done safely, because it doesn't involve any preconditions. Function `f` converts a safe reference `x` to an lvalue reference with a dereference and borrow: `&*x`. Going the other way is unsafe: the precondition of the _unsafe-block_ is that the legacy references _do not alias_ and _do not dangle_: `%*x`.
+While safe references and legacy references are different types, they're inter-convertible. Converting a safe reference to legacy reference can be done safely, because it doesn't involve any preconditions. Function `f` converts a safe reference `x` to an lvalue reference with a dereference and reference-of: `&*x`. Going the other way is unsafe: the precondition of the _unsafe-block_ is that the legacy references _do not alias_ and _do not dangle_: `%*x`.
 
 ## Constraint rules
-Original file line number
+Diff line change
@@ Expand Up / @@ -175,7 +175,7 @@ void f(int% x, int% y) safe { @@
     }
     ```
-    While safe references and legacy references are different types, they're inter-convertible. Converting a safe reference to legacy reference can be done safely, because it doesn't involve any preconditions. Function `f` converts a safe reference `x` to an lvalue reference with a dereference and borrow: `&*x`. Going the other way is unsafe: the precondition of the _unsafe-block_ is that the legacy references _do not alias_ and _do not dangle_: `%*x`.
+    While safe references and legacy references are different types, they're inter-convertible. Converting a safe reference to legacy reference can be done safely, because it doesn't involve any preconditions. Function `f` converts a safe reference `x` to an lvalue reference with a dereference and reference-of: `&*x`. Going the other way is unsafe: the precondition of the _unsafe-block_ is that the legacy references _do not alias_ and _do not dangle_: `%*x`.
     ## Constraint rules
@@ Expand Down @@