I'd say there are a couple of things that apply: * `?` can propagate values/short circuit control flow, but it also contains a hidden type conversion. The targ

I'd say there are a couple of things that apply: * `?` can propagate values/short circuit control flow, but it also contains a hidden type conversion. The target needs to be a known type for it to compile. * A proposed `catch` construct will include implicit type conversion for its result value. Some things that came up in the past but met resistance: * Removing project structure from in-code to being defined by the filesystem. * Hiding `Result` types in signatures with special syntax. * Dropping immutable by default, though this was pre-1.0. Also, `Rc` and `Arc` are good examples for this. They do seem trivial, but having them auto-clone would mean: * Every newcomer who writes `fn foo(val: Arc<Bar>) {}` instead of `fn foo(val: &Arc<Bar>) {}` or `fn foo(val: &Bar) {}` will get an implicit atomic increment/decrement at every function call. * It also makes it a lot harder to reason about code if you want to use a clone-on-mutation-unless-not-shared strategy.