Stop making me memorize the borrow checker

Yes, and people should stop using Rust for projects that do not require a systems programming language.

Know what tool to pick.

It's a high level language with algebraic data types and fantastic type checking. I'll use it where ever I darn well please.

Sometimes I write Rust with Arc and Rc sprinkled everywhere because I just need a dialect of OCaml.

The only thing that's really missing is deref patterns so that you can pattern match on an Arc<T> with a T pattern.

Shouldn't this be possible already? Deref is implemented for Arc<T>.

[1] https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-Dere...

[2] https://rust-lang.github.io/rfcs/2005-match-ergonomics.html

I mean having the following work:

  match Arc::new("hello") {
      "hi" => {}
      "hello" => {}
      _ => {}
  }

It is an extension of match ergonomics, called deref patterns. There's some experimental code to make it work for `String` to `&str` (`if let "hi" = String::from("hi") {}`), but it is not anywhere close to finished. The final version will likely have something like a `trait DerefPure: Deref {}` signaling trait. There is disagreement on whether giving users the possibility to execute non-idempotent, non-cheap behavior on `Deref` and allow them to `impl DerefPure` for those types would be a big enough foot-gun to restrict this only to std or not.

What's the difference and advantage, other than less typing, of this over:

     match *Arc::new("hello").as_ref() {
      "hi" => {}
      "hello" => {}
      _ => {}

(Sorry, Rust newbie here)