相关疑难解决方法(0)

我..=在一些Rust代码中看到了这个运算符:

for s in 2..=9 {
    // some code here
}

它是什么？

如何生成包含Rust中所有整数的列表？我正在寻找相当于Haskell [n..m]或Python的,range(n, m+1)但找不到任何东西.

我知道这个int::range功能,并认为这是我正在寻找的东西,但它是在一个范围内迭代,而不是产生它.

我的函数实现的实验结果有些问题,我希望其他人验证我使用的函数在逻辑上是合理的.

上下文:对于某个编程/数学问题,我需要计算连续间隔内的平均值到给定精度的10个小数位.该函数相当复杂并且涉及两个维度,因此我更喜欢在计算连续平均值(因此必须在两个维度中集成函数)时执行和近似.

为了帮助我,我一直在研究Rust中的一组近似函数.它们使用Riemann和,梯形法则或Simpson规则计算具有固定增量f的区间内函数的离散平均值,具体取决于实现:a..bdelta

pub fn riemann_avg<F>(a: f64, b: f64, delta: f64, f: F) -> f64
where
    F: Fn(f64) -> f64
{
    let n = ((b - a) / delta) as usize;

    (0..n)
        .map(|i| (i as f64) * delta)
        .map(f)
        .sum::<f64>() / (n as f64)
}


pub fn trapezoidal_avg<F>(a: f64, b: f64, delta: f64, f: F) -> f64
where
    F: Fn(f64) -> f64
{
    let n = ((b - a) / delta) as usize;

    (0..n)
        .map(|i| …

Rust Book的Operators and Symbols附录列出了两个都是右包含范围的运算符：

这两个运营商有什么区别？或者，换种说法，范围文字和范围模式之间有什么区别？

'In a pattern' 表示expr...expr必须在匹配表达式中使用，expr..=expr而不应该使用。为什么是这样？

我正在尝试迭代所有可能的byte(u8)值.不幸的是在我的范围内的文字0..256被强制转换为u8和256溢出:

fn foo(byte: u8) {
    println!("{}", byte);
}

fn main() {
    for byte in 0..256 {
        foo(byte);
        println!("Never executed.");
    }
    for byte in 0..1 {
        foo(byte);
        println!("Executed once.");
    }
}

以上编译:

warning: literal out of range for u8
 --> src/main.rs:6:20
  |
6 |     for byte in 0..256 {
  |                    ^^^
  |
  = note: #[warn(overflowing_literals)] on by default

第一个循环体永远不会被执行.

由于演员阵容,我的解决方法非常难看并且感觉很脆弱:

for short in 0..256 {
    let _explicit_type: u16 = short;
    foo(short as u8); …

我正在尝试生成包含小写ASCII字符的向量.这种更复杂的方法有效:

let ascii_lowercase = (b'a'..=b'z').map(|b| b as char).collect::<Vec<char>>();

但是,我首先提出的这个更直接的方法并不是:

let ascii_lowercase = ('a'..='z').collect::<Vec<char>>();

错误是:

error[E0599]: no method named `collect` found for type `std::ops::RangeInclusive<char>` in the current scope
 --> src/main.rs:2:39
  |
2 |     let ascii_lowercase = ('a'..='z').collect::<Vec<char>>();
  |                                       ^^^^^^^
  |
  = note: the method `collect` exists but the following trait bounds were not satisfied:
          `std::ops::RangeInclusive<char> : std::iter::Iterator`
          `&mut std::ops::RangeInclusive<char> : std::iter::Iterator`

这是奇怪的,因为据我了解,有一个铺盖实现Iterator的RangeInclusive.

是否不可能使用一系列字符作为迭代器？如果是这样,为什么？如果没有,我做错了什么？我正在使用稳定的Rust 2018 1.31.1.

这个问题使用早于Rust 1.0的语法,但概念是通用的,并且许多答案已经更新以反映稳定的Rust 1.0.

这个问题是程序员在学习Rust时可能尝试的一个非常基本的问题.

你不能问一个关于Rust语言的简单问题,我不认为,但我是一名有30年经验的程序员,我无法理解.

我认为它int::range与闭包有关.

这是我在Rust的早期版本(1.0之前版)中所写的内容.

fn main() {
    int::range(0, 100, {|i| 
        io::println(i);
    });
}

这会创建可爱的错误消息,我不知道如何修复:

hello.rs:3:19: 5:2 error: mismatched types: expected `&fn(int) -> bool` but found `()` (expected fn but found ())
hello.rs:3 int::range(0, 100, {|i| 
hello.rs:4     io::println(i);
hello.rs:5 });

它如何打印出我的整个功能体,这很有趣,但我仍然不知道那是&fn(int) ->b ool什么意思.我隐约怀疑有一个迭代器的闭包体没有声明任何返回类型在Rust中明确禁止,这让我感到困惑.

我正在尝试创建pub fn sing(start: i32, end: i32) -> String它返回一个串联的字符串,pub fn verse(num: i32) -> String重复调用每个数字之间start和end.

我用google搜索答案,看起来Rust String连接回答了我的问题,如果我甚至在操场上编写我的代码就行了,但是:

我的代码:

pub fn verse(num: i32) -> String {
    match num {
        0 => "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n".to_string(),
        1 => "1 bottle of beer on the wall, 1 bottle of beer.\nTake …