<div dir="ltr"><div><div><div>FYI: I did a RFC for separating mut and "only" some times ago: <a href="https://github.com/rust-lang/rfcs/pull/78#">https://github.com/rust-lang/rfcs/pull/78#</a><br><br></div>I invite the interested readers to check it out and read the comments (notably those by thestinger, aka Daniel Micay on this list).<br>
<br></div>For now, my understanding was that proposals on the topic were suspended until the dev team manages to clear its plate of several big projects (such as DST), especially as thestinger had a proposal to change the way lambda captures are modeled so it no longer requires a "&uniq" (only accessible to the compiler).<br>
<br></div>-- Matthieu<br><div><br></div></div><div class="gmail_extra"><br><br><div class="gmail_quote">On Sun, Jun 1, 2014 at 2:32 AM, Patrick Walton <span dir="ltr"><<a href="mailto:pwalton@mozilla.com" target="_blank">pwalton@mozilla.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div style="word-wrap:break-word">Yes, you could eliminate (c) by prohibiting taking references to the inside of sum types (really, any existential type). This is what Cyclone did. For (e) I'm thinking of sum types in which the two variants have different sizes (although maybe that doesn't work).<br>

<br>
We'd basically have to bring back the old &mut as a separate type of pointer to make it work. Note that Niko was considering a system like this in older blog posts pre-INHTWAMA. (Search for "restrict pointers" on his blog.)<span class="HOEnZb"><font color="#888888"><br>

<br>
Patrick <br></font></span><div><div class="h5"><br><div class="gmail_quote">On May 31, 2014 5:26:39 PM PDT, Cameron Zwarich <<a href="mailto:zwarich@mozilla.com" target="_blank">zwarich@mozilla.com</a>> wrote:<blockquote class="gmail_quote" style="margin:0pt 0pt 0pt 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">

<div>FWIW, I think you could eliminate (c) by prohibiting mutation of sum types. What case are you thinking of for (e)?</div><div><br></div><div>For (d), this would probably have to be distinguished from the current &mut somehow, to allow for truly unique access paths to sum types or shared data, so you could preserve any aliasing optimizations for the current &mut. Of course, more functions might take the less restrictive version, eliminating the optimization that way.</div>
<div><br></div><div>Not that I think that this is a great idea; I’m just wondering whether there are any caveats that have escaped my mental model of the borrow checker.</div><div><br></div><div>Cameron</div><div><br></div>
<div><div>On May 31, 2014, at 5:01 PM, Patrick Walton <<a href="mailto:pwalton@mozilla.com" target="_blank">pwalton@mozilla.com</a>> wrote:</div><br><blockquote type="cite"><div style="word-wrap:break-word">I assume what you're trying to say is that we should allow multiple mutable references to pointer-free data. (Note that, as Huon pointed out, this is not the same thing as the Copy bound.)<br>

<br>
That is potentially plausible, but (a) it adds more complexity to the borrow checker; (b) it's a fairly narrow use case, since it'd only be safe for pointer-free data; (c) it admits casts like 3u8 -> bool, casts to out-of-range enum values, denormal floats, and the like, all of which would have various annoying consequences; (d) it complicates or defeats optimizations based on pointer aliasing of &mut; (e) it allows uninitialized data to be read, introducing undefined behavior into the language. I don't think it's worth it. <br>

<br>
Patrick<br><br><div class="gmail_quote">On May 31, 2014 4:42:10 PM PDT, Tommi <<a href="mailto:rusty.gates@icloud.com" target="_blank">rusty.gates@icloud.com</a>> wrote:<blockquote class="gmail_quote" style="margin:0pt 0pt 0pt 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">

On 2014-06-01, at 1:02, Patrick Walton <<a href="mailto:pcwalton@mozilla.com" target="_blank">pcwalton@mozilla.com</a>> wrote:<br><div><br><blockquote type="cite"><span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">   fn my_transmute<T:Clone,U>(value: T, other: U) -> U {</span><br style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px">
<span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">       let mut x = Left(other);</span><br style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px">
<span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">       let y = match x {</span><br style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px">
<span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">           Left(ref mut y) => y,</span><br style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px">
<span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">           Right(_) => fail!()</span><br>
<span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">       };</span><br style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px">
<span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">       *x = Right(value);</span><br style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px">
<span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">       (*y).clone()</span><br style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px">
<span style="font-family:Helvetica;font-size:12px;font-style:normal;font-variant:normal;font-weight:normal;letter-spacing:normal;line-height:normal;text-align:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:0px;float:none;display:inline!important">   }</span></blockquote>
</div><br><div>If `U` implements `Copy`, then I don't see a (memory-safety) issue here. And if `U` doesn't implement `Copy`, then it's same situation as it was in the earlier example given
  by
Matthieu, where there was an assignment to an `Option<Box<str>>` variable while a different reference pointing to that variable existed. The compiler shouldn't allow that assignment just as in your example the compiler shouldn't allow the assignment `x = Right(value);` (after a separate reference pointing to the contents of `x` has been created) if `U` is not a `Copy` type.</div>
<div><br></div><div>But, like I said in an earlier post, even though I don't see this (transmuting a `Copy` type in safe code) as a memory-safety issue, it is a code correctness issue. So it's a compromise between preventing logic bugs (in safe code) and the convenience of more liberal mutation.</div>
<div><br></div></blockquote></div><br>
-- <br>
Sent from my Android phone with K-9 Mail. Please excuse my brevity.</div>_______________________________________________<br>Rust-dev mailing list<br><a href="mailto:Rust-dev@mozilla.org" target="_blank">Rust-dev@mozilla.org</a><br>
<a href="https://mail.mozilla.org/listinfo/rust-dev" target="_blank">https://mail.mozilla.org/listinfo/rust-dev</a><br></blockquote></div><br></blockquote></div><br>
-- <br>
Sent from my Android phone with K-9 Mail. Please excuse my brevity.</div></div></div><br>_______________________________________________<br>
Rust-dev mailing list<br>
<a href="mailto:Rust-dev@mozilla.org">Rust-dev@mozilla.org</a><br>
<a href="https://mail.mozilla.org/listinfo/rust-dev" target="_blank">https://mail.mozilla.org/listinfo/rust-dev</a><br>
<br></blockquote></div><br></div>