Question

我正在尝试学习Rust语言及其编码风格。我想使用几个独立的变量，但是使用来自函数f的相同值进行初始化：

let (mut a, mut b) = (f(), f());

然而，它调用f两次，所以最好这样做：

let mut a = f()
let mut b = a

是否可以像在caml中那样在一行中完成？

let (a,b) = (c,c) where c = f()
(* or *)
let c = f() in let (a,b) = c;

Answer 1

您可以使用块来引入具有受限范围的变量。

let (mut a, mut b) = { let c = f(); (c, c) };

或者，更清晰：

let (mut a, mut b) = {
    let c = f();
    (c, c)
};

块是表达式，它们计算为它们体内的最后一个表达式，除非该表达式后面跟一个分号，在这种情况下，块的计算结果为()。

Answer 2

您可以定义将值转换为元组的特征，并为所有可复制类型实现它：

trait AsTuple where Self:Copy{
    #[inline]
    fn as_tuple(self) -> (Self, Self) {(self, self)}
}

impl<T:Copy> AsTuple for T {}



fn get_value() -> u32{
    42
}

fn main() {
    let (a, b) = get_value().as_tuple();
    println!("{} {}", a,b);
}

类似地，您可以使用相同的参数调用函数：

trait ApplySame where Self:Copy{
    #[inline]
    fn apply_same<R, F: Fn(Self, Self) -> R>(self, f:F) -> R {f(self,self)}
}

impl<T:Copy> ApplySame for T {}

fn sum_it(a:u16, b: u16) -> u16 { a + b }

fn print_me(a:u8, b:u8){
    println!("a:{}, b:{}", a, b);
}

fn get_value() -> u16 { 21 }

fn main() {
    println!("{}", get_value().apply_same(sum_it));
    1u8.apply_same(print_me);
}

Answer 3

不知何故，但不要这样做。

如果您的目标确实是将其写在一行，只需在一行上写下let a = f(); let b = a;。
如果您的目标是拥有let in表达式，则可以使用块来执行此操作：

f({ let a = g(); h(a, a) });

等同于ocaml：

f(let a = g() in h(a, a));

但它们中没有一个真的是惯用的。

当地人喜欢在caml

3 个答案: