requiring positional args to use the assignment syntax
Not sure, maybe my wording isn’t clear enough.
What I intended to say is that arguments can be named, not that they have to.
In any case, the order of arguments must match the order of parameters, named or not.
But you’re also missing one use of the impl keyword: fn func() -> impl Trait.
That removal could actually happen, so I didn’t list it. (Rust started requiring dyn and disallowed naked trait returns with edition 2018. So dropping the impl in that position might not be completely impossible like the other uses of impl.)
Are you suggesting using keywords/methods [for array and slice syntax] instead?
Yes, just methods.
I can understand someone preferring the PartialEq/PartialOrd behavior
You can have both – that’s what’s being made possible by them not being in a hierarchy.
I think if-let makes sense, but don’t expand it.
It’s a bit late for that, isn’t it? ;-)
Why? What value does -> () provide? Why not elide that?
What value is provided by keeping it? Why a syntactic special-case for exactly that type and not any other random type?
languages w/o them feel awkward since you’re generally limited to one statement per line
But you’re also missing one use of the impl keyword: fn func() -> impl Trait.
[…] So dropping the impl in [return position] might not be completely impossible like the other uses of impl.
But the impl markes that it is a trait to the programmers.
Take the following functions:
func1()->A{...}
func2()->A{...}
Does the following snippet compile?
let mut thing = func1();
thing = func2();
Under the current rules we know it will. But if A could be a trait, the functions could return different types. We currently mark that with the impl.
Why? What value does -> () provide? Why not elide that?
What value is provided by keeping it?
What value does cluttering up your code with -> () provide?
Why a syntactic special-case for exactly that type and not any other random type?
Because the unit type is special, just like the never ! type. () also has the special importance of being the return value of an empty statement and some other stuff.
languages w/o [semicolons] feel awkward since you’re generally limited to one statement per line
Thanks for your reply, some replies below!
Not sure, maybe my wording isn’t clear enough. What I intended to say is that arguments can be named, not that they have to. In any case, the order of arguments must match the order of parameters, named or not.
That removal could actually happen, so I didn’t list it. (Rust started requiring
dynand disallowed naked trait returns with edition 2018. So dropping theimplin that position might not be completely impossible like the other uses ofimpl.)Yes, just methods.
You can have both – that’s what’s being made possible by them not being in a hierarchy.
It’s a bit late for that, isn’t it? ;-)
What value is provided by keeping it? Why a syntactic special-case for exactly that type and not any other random type?
Then fixing that might make sense. :-)
But the impl markes that it is a trait to the programmers.
Take the following functions:
func1()->A{...} func2()->A{...}Does the following snippet compile?
let mut thing = func1(); thing = func2();Under the current rules we know it will. But if A could be a trait, the functions could return different types. We currently mark that with the
impl.What value does cluttering up your code with
-> ()provide?Because the unit type is special, just like the never
!type.()also has the special importance of being the return value of an empty statement and some other stuff.It’s fixed with semicolons ;-)