Recently withoutboats posted a
series of blog
posts about some syntax
sugar he would like added to Rust.
The gist of it is, as far as I can tell, there should be some way to not have to
Ok(...) for the happy path in functions which return
specifically is advocating for a
throws keyword that would go a bit beyond
just this basic change, but the problem he’s mainly trying to fix is having to
Ok(...) so often.
I haven’t really been involved with the Rust community that much, especially
since I stopped working on Way Cooler. This isn’t from lack of using Rust, I
use Rust in my day job after all, but rather from disinterest in getting
involved in what seems to be mostly bikeshedding. The
.await war was the final
straw to make me stop watching the Rust community beyond what comes in the
So in many ways I’m coming into this argument as an outsider – I have not read
any thing beyond the two linked blog posts and am missing most of the discussion
that has gone on. I’m not going to weigh in on
throws vs some annotation vs
Fehler because even though I have an opinion I detest bikeshedding.
However, as a long time user of Rust (4 years, wow how time flies!) the
constantly changing standard of what constitutes “idiomatic Rust” is starting to
wear me down.
?, the addition of
impl trait, and the
keyword are all features that have changed what it means to write idiomatic
Rust. When these features come out I need to now change my code in order to keep
That’s not to say I hate these features. I remember being very happy when
came about and
dyn is certainly clearer than what we had before. However
having to make these superficial changes again and again causes churn in all my
codebases. Because Rust releases every 6 weeks that means every 6 weeks I might
need to make superficial changes to my codebase (not to mention potentially have
to do a major point release – using
impl is an API breaking change).
So to bring my complaints back around to the issue at hand: if
came in the next Rust release this would be another change that requires me to
update my code in order to be idiomatic. This isn’t sustainable for me – I
appreciate Rust team’s commitment to backwards compatibility but the constant
disregard for forwards-compatibility makes me feel like I’m on a treadmill
trying, and failing, to keep up.