小编Eri*_*aas的帖子

在浏览JavaJ版本的ForkJoinPool的代码时(我从Java 7中进行了一些有趣的更改),我遇到了这个构造(这里):

do {} while (!blocker.isReleasable() &&
             !blocker.block());

我正在努力为什么你会这样写,而不是只是

while (!blocker.isReleasable() &&
       !blocker.block());

它只是一个语义/可读性选择,因为你可以读取第一个结构do "nothing" while "conditions"吗？或者我还缺少一些额外的好处？

在下面的示例程序中,有什么方法可以避免必须定义map2吗？

fn map2<T, U, V, F: Fn(T, U) -> V>(f: F, a: Option<T>, b: Option<U>) -> Option<V> {
    match a {
        Some(x) => match b {
            Some(y) => Some(f(x, y)),
            None => None,
        },
        None => None,
    }
}

fn main() {
    let a = Some(5);
    let b = Some(10);
    let f = |a, b| {
        a + b
    };
    let res = map2(f, a, b);
    println!("{:?}", res);
    // prints Some(15)
}

对于那些也讲Haskell的人来说,我想这个问题也可以被称为"我们可以使用任何工具而不是Rust中的liftM2吗？"

在Rust中的类型提示中,可以在注释中使用部分类型,如下所示:

let myvec: Vec<_> = vec![1, 2, 3];

部分类型注释中下划线的正确术语是什么？我对Rust术语以及更多学术类型理论术语感兴趣.

在编写具有特征的代码时,您可以将特征置于特征界限中:

use std::fmt::Debug;

fn myfunction1<T: Debug>(v: Box<T>) {
    println!("{:?}", v);
}

fn myfunction2<T: Debug>(v: &T) {
    println!("{:?}", v);
}

fn main() {
    myfunction1(Box::new(5));
    myfunction2(&5);
}

或直接使用Box或引用类型:

use std::fmt::Debug;

fn myfunction3(v: Box<Debug>) {
    println!("{:?}", v);
}

fn myfunction4(v: &Debug) {
    println!("{:?}", v);
}

fn main() {
    myfunction3(Box::new(5));
    myfunction4(&5);
}

这些输出相同.那么区别是什么呢？

(这个问题的灵感来自另一个问题,这只是几个混合概念中的一个)

引用包装类一样&Rc<T>,并&Box<T>在不变的T(&Rc<T>是不是&Rc<U>就算T是U).问题的一个具体例子(Rust Playground):

use std::rc::Rc;
use std::rc::Weak;

trait MyTrait {}

struct MyStruct {
}

impl MyTrait for MyStruct {}

fn foo(rc_trait: Weak<MyTrait>) {}

fn main() {
    let a = Rc::new(MyStruct {});
    foo(Rc::downgrade(&a));
}

此代码导致以下错误:

<anon>:15:23: 15:25 error: mismatched types:
 expected `&alloc::rc::Rc<MyTrait>`,
    found `&alloc::rc::Rc<MyStruct>`

类似的例子(有类似的错误)与Box<T>(Rust Playground):

trait MyTrait {}

struct MyStruct {
}

impl MyTrait for MyStruct {}

fn foo(rc_trait: &Box<MyTrait>) {} …

在Kotlin中，如果我们有一个带有构造函数的类：

open class Wrapper<T>(val value: T)

我们可以在不指定type参数的情况下调用构造函数：

val wrapped = Wrapper("value")

指定类型参数（例如Wrapper<String>("value")）是多余的，IntelliJ会告诉您。

但是，如果构造函数调用是extend子句，则type参数是必需的。例如

class StringWrapper : Wrapper<String>("value") // compiles
class StringWrapper : Wrapper("value") // does not compile

为什么在这种看似非常相似的情况下无法推断出type参数？