How to pattern match on `&Box<T>` without using `as_ref` - rust

Question

Is there any way to pattern match on an &Box<T> without using as_ref? I'm using stable Rust, so the answer can't involve box_patterns.
Essentially, I have code like this:
enum Foo {
Thing(Box<ThingKind>),
}
enum ThingKind {
One(Foo),
Two(Foo, Foo),
}
fn my_function(foo: &Foo) {
match foo {
Foo::Thing(ThingKind::One(_inner)) => { /* ... */ }
Foo::Thing(ThingKind::Two(_left, _right)) => { /* ... */ }
}
}
but the compiler doesn't like that:
error[E0308]: mismatched types
--> src/lib.rs:12:20
|
11 | match foo {
| --- this expression has type `&Foo`
12 | Foo::Thing(ThingKind::One(_inner)) => { /* ... */ }
| ^^^^^^^^^^^^^^^^^^^^^^ expected struct `Box`, found enum `ThingKind`
|
= note: expected struct `Box<ThingKind>`
found enum `ThingKind`
error[E0308]: mismatched types
--> src/lib.rs:13:20
|
11 | match foo {
| --- this expression has type `&Foo`
12 | Foo::Thing(ThingKind::One(_inner)) => { /* ... */ }
13 | Foo::Thing(ThingKind::Two(_left, _right)) => { /* ... */ }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `Box`, found enum `ThingKind`
|
= note: expected struct `Box<ThingKind>`
found enum `ThingKind`
error: aborting due to 2 previous errors
Then I tried this instead:
enum Foo {
Thing(Box<ThingKind>),
}
enum ThingKind {
One(Foo),
Two(Foo, Foo),
}
fn my_function(foo: &Foo) {
match foo {
Foo::Thing(kind) => match kind {
ThingKind::One(_inner) => { /* ... */ }
ThingKind::Two(_left, _right) => { /* ... */ }
},
}
}
but the compiler gives a similar error on that one as well.
Then I tried using kind.as_ref() in the inner match, which does work, but it's kind of annoying to have to add that every time. So, is there any way to do it without as_ref?

Answer 1

This looks like a job for std::ops::Deref.
enum Foo {
Thing(Box<ThingKind>),
}
enum ThingKind {
One(Foo),
Two(Foo, Foo),
}
impl std::ops::Deref for Foo {
type Target = ThingKind;
fn deref(&self) -> &Self::Target {
match self {
Foo::Thing(b) => &*b,
}
}
}
fn my_function(foo: &Foo) {
match &**foo {
ThingKind::One(_inner) => { /* ... */ }
ThingKind::Two(_left, _right) => { /* ... */ }
}
}