accompany

with 样式的宏用于 Rust，它有助于缩小变量的生命周期。

用法

安装：将 accompany = "0.2.0" 添加到您的 Cargo.toml。

示例

use accompany::bound;
let i = bound!{
    with j = 1 => {
        let m = j + 1;
        m
    }
};

这将翻译为

let i ={
    let j = 1;
    let m = j + 1;
    m
};

或者简单地

let i = bound!{
    with j = 1 => j + 1
};

您可以对多个重要的变量使用 with。

let i = bound!{
    with j = 1, k =1 => {
        let m = j + k;
        m
    }
};

此外，还支持结构体和元组的销毁。

let tup = (1,2);
let i = bound!{
    with (i,j) = tuple =>{
        let m= i+j;
        m
    }
};

pub struct A{
    pub field: u8,
}

let a = A{ field : 0};
let i = bound!{
    with A {field: mut i} = a => {
        i += 1;
        let m = i + 1;
        m
    }
};

这并不是什么花哨的东西，但它有助于跟踪和限制重要变量的生命周期。

当 rustc 无法缩小关键变量的生命周期并因此抛出编译错误时，特别有用。

例如

struct B {
    pub field: u8,
}

struct C<'a> {
    pub some_mut_ref: &'a mut u8,
}

impl Drop for C<'_> {
    fn drop(&mut self) {
        *self.some_mut_ref += 1;
    }
}

impl B {
    pub fn return_c<'a>(&'a mut self) -> C<'a> {
        C { some_mut_ref: &mut self.field}
    }
}


fn main() {
    let mut b = B { field: 0 };
    let mut c : C = b.return_c();
    println!("{}", c.some_mut_ref);
    // expect `c` is dropped here
    let ref_to_b = &b;
    println!("{}", ref_to_b.field);
    // actually `c` is dropped here, thus rustc gives a compile error
}

现在使用 bound!{}，我们可以这样做

fn main() {
    let mut b = B { field: 0 };
    bound!{
        with mut c = b.return_c() => {
            println!("{}", c.some_mut_ref);
        }
    } // `c` is dropped right here
    let ref_to_b = &b;
    println!("{}", ref_to_b.field);
}

这比下面的更好，下面的没有强调重要的变量。

fn main() {
    let mut b = B { field: 0 };
    {
        let mut c = b.return_c();
        println!("{}", c.some_mut_ref);
    } // `c` is dropped right here
    let ref_to_b = &b;
    println!("{}", ref_to_b.field);
}