#match #deref

macro match_deref

Deref patterns in "match" for stable Rust. Now you can match through Rc, String, etc

1 unstable release

0.1.1 Jul 29, 2022
0.1.1-alpha.1 Jul 28, 2022
0.1.0 Jul 28, 2022
Download history 13/week @ 2023-05-28 20/week @ 2023-06-04 13/week @ 2023-06-11 17/week @ 2023-06-18 13/week @ 2023-06-25 17/week @ 2023-07-02 9/week @ 2023-07-09 12/week @ 2023-07-16 13/week @ 2023-07-23 7/week @ 2023-07-30 10/week @ 2023-08-06 13/week @ 2023-08-13 26/week @ 2023-08-20 10/week @ 2023-08-27 13/week @ 2023-09-03 18/week @ 2023-09-10

68 downloads per month
Used in ezno-parser


316 lines

Deref patterns in match for stable Rust. Now you can match through Rc, String, etc.

match_deref::match_deref!{...} is a procedural macro, which allows you to use deref patterns right now in stable Rust.

For example:

use std::rc::Rc;

enum Value {
    Cons(Rc<Value>, Rc<Value>),

use Value::*;

let v: &Value = todo!();
    match v {
        Nil => todo!(),
        Cons(Deref @ Symbol(Deref @ "quote"), Deref @ Cons(x, Deref @ Nil)) => todo!(),
        _ => todo!(),

But there is a problem in my crate: all arms with Deref @ are ignored when compiler performs exhaustiveness checking. So sometimes you will need to add _ => unreachable!() to the end.

I. e. it is possible that your arms are exhaustive, but the compiler will not be able to check this. But it is not possible that you arms are not exhaustive and the compiler will falsely report them as exhaustive.

(I decided not to implement full exhaustiveness checking, because I hope that truly native support for deref patterns will be implemented in the rustc soon, so my work will be unneeded anyway. But if you want to implement similar macro with full exhaustiveness checking, go ahead, I can even link to your project here.)

The macro calls Deref::deref internally. Keep in mind that Deref::deref takes REFERENCE to smart pointer and returns REFERENCE to pointee. So this code will work: match &Nil { Deref @ x => ... }, but this will not: match Nil { Deref @ x => ... }.

Consider this code:

    match v {
        Symbol(Deref @ x) => some_code_here,
        _ => other_code_here,

It will be desugared to something like this:

match v {
    Symbol(a0) if (if let x = Deref::deref(a0) { true } else { false }) => if let x = Deref::deref(a0) {
    } else {
    _ => other_code_here,

My macro is hygienic, i. e. everything will work even if you use variable named a0

You don't need to be registered on SourceHut to create bug report.

If you think that this software is not needed or existing software already subsumes its functionality, please, tell me that, I will not be offended.


~31K SLoC