There's also the fact that the exchange heap is the default place to allocate,
so anything that needs an object (e.g. "in") doesn't work, as "in Unique" would
probably be too verbose.
Looking like C++ is a goal of Rust, in any case...
Patrick
Kevin Ballard <ke...@sb.org> wrote:
>As I said in the IRC channel, the reason why users often don't realize
>that `~T` is allocation, is not a failure of syntax, but a failure of
>documentation. The only reason why a user would know that `new Foo`
>allocates is because they've been exposed to that syntax from another
>language, one that actually documents the fact that it allocates. Users
>who haven't been exposed to `new Foo` from other languages will have no
>reason to understand that this allocates without being told that it
>allocates.
>
>As such, there is no reason why we cannot simply fix the documentation
>to explain that `~` is the allocation operator, and that when it's used
>in an expression it means it allocates a value.
>
>It was then explained to me that the "real" reason we needed `new`
>wasn't because of the issues with users understanding allocation, but
>because of a need for placement new. That is why I suggested some
>alternative syntaxes.
>
>Also, FWIW, `~(n + m)` makes sense, as a way of producing an allocated
>value from the result of `n + m`, but `new (n + m)` is pretty
>nonsensical.
>
>-Kevin
>
>On Nov 29, 2013, at 10:48 PM, Patrick Walton <pwal...@mozilla.com>
>wrote:
>
>> None of these look like allocation.
>>
>> Patrick
>>
>> Kevin Ballard <ke...@sb.org> wrote:
>> I am very saddened by the fact that we're apparently reserving `new`
>as a keyword, and even more by the fact that the proposed placement new
>syntax is `new(foo) bar`. This looks exactly like C++, and it goes
>against the strong precedence we already have of using new() as a
>static function for types. Path::init("foo") looks extremely wrong to
>me.
>>
>> Surely there's another syntax we can use for placement new that
>doesn't involve reserving `new` as a keyword? Here's a few random ideas
>(where "val" is the value expression and "place" is the place
>expression):
>>
>> ~in(place) val
>> in(place) ~val
>> ~val in place (assuming this isn't somehow ambiguous)
>> ~~val in place (the existing ~~val would have to be written ~(~val))
>> ~~(place) val (the existing ~~val would have to be written ~(~val))
>> ~<place> val
>> ~=place val
>> ~>place val (this looks like an arrow pointing to the place)
>> ~>(place) val
>>
>> Personally I think `~in(place) val` is perfectly fine. It's not the
>prettiest of syntaxes, but placement new should be very rare, and this
>allows us to avoid reserving `new` and continue to use ~ as the
>allocation operator.
>>
>> -Kevin
>>
>>
>> Rust-dev mailing list
>> Rust-dev@mozilla.org
>> https://mail.mozilla.org/listinfo/rust-dev
>>
>> --
>> Sent from my Android phone with K-9 Mail. Please excuse my brevity.
--
Sent from my Android phone with K-9 Mail. Please excuse my brevity._______________________________________________
Rust-dev mailing list
Rust-dev@mozilla.org
https://mail.mozilla.org/listinfo/rust-dev
