标签: rust-obsolete

TypeState在语言设计方面提到了什么？我在一些关于mozilla称为Rust的新语言的讨论中看到了它.

此问题适用于Rust的预发布版本.
这个年轻的问题很相似.

我试图按io::println功能打印一个符号

fn main() {
    io::println('c');
}

但我得到了下一个错误:

$ rustc pdst.rs 
pdst.rs:2:16: 2:19 error: mismatched types: expected `&str` but found `char` (expected &str but found char)
pdst.rs:2     io::println('c');
                          ^~~
error: aborting due to previous error

如何将char转换为字符串？

UPDATE

直接类型转换不起作用:

let text:str = 'c';
let text:&str = 'c';
let text:@str = 'c';
let text:~str = 'c';

它返回:

pdst.rs:7:13: 7:16 error: bare `str` is not a type
pdst.rs:7     let text:str = 'c';
                       ^~~
pdst.rs:7:19: 7:22 error: mismatched types: expected …

编者注:实施RFC 599后,此代码不再产生相同的错误,但答案中讨论的概念仍然有效.

我正在尝试编译此代码:

trait A {
    fn f(&self);
}

struct S {
    a: Box<A>,
}

我收到这个错误:

a.rs:6:13: 6:14 error: explicit lifetime bound required
a.rs:6     a: Box<A>,

我想S.a拥有一个实例A,并且不知道这个生命周期是如何合适的.我需要做些什么才能使编译器满意？

我的Rust版本:

rustc --version
rustc 0.12.0-pre-nightly (79a5448f4 2014-09-13 20:36:02 +0000)

这是针对当前0.6 Rust的干线,不确定确切的提交.

假设我想在每个字符串中使用,并且我的闭包采用了一个借用的字符串指针参数(&str).我希望我的闭包将其参数添加到拥有的字符串〜[〜str]的拥有向量中以便返回.我对Rust的理解很弱,但我认为字符串是一个特殊情况,你不能用*右解引它们？如何将我的字符串从&str转换为vector的push方法,该方法需要~str？

这是一些无法编译的代码

fn read_all_lines() -> ~[~str] {
    let mut result = ~[];
    let reader = io::stdin();
    let util = @reader as @io::ReaderUtil;
    for util.each_line |line| {
        result.push(line);
    }
    result
}

它不会编译,因为它推断结果的类型是[&str],因为那是我正在推动的.更不用说它的生命周期是错误的,因为我正在添加一个寿命较短的变量.

我意识到我可以使用ReaderUtil的read_line()方法返回一个~str.但这只是一个例子.

那么,如何从借来的字符串中获取拥有的字符串？或者我完全是误解.

在搜索如何使用Rust生成随机数时,我遇到了以下示例.但是,它似乎没有用......示例似乎没有显示它适用于哪个版本的Rust,所以也许它已经过时了,或者我可能出错了.

// http://static.rust-lang.org/doc/master/std/rand/trait.Rng.html

use std::rand;
use std::rand::Rng;

fn main() {
    let mut rng = rand::task_rng();
    let n: uint = rng.gen_range(0u, 10);
    println!("{}", n);
    let m: float = rng.gen_range(-40.0, 1.3e5);
    println!("{}", m);
}

当我尝试编译它时,会产生以下结果:

test_rand002.rs:6:17: 6:39 error: type `@mut std::rand::IsaacRng` does not
implement any method in scope named `gen_range`
test_rand002.rs:6    let n: uint = rng.gen_range(0u, 10);
                                   ^~~~~~~~~~~~~~~~~~~~~~
test_rand002.rs:8:18: 8:46 error: type `@mut std::rand::IsaacRng` does not
implement any method in scope named `gen_range`
test_rand002.rs:8    let m: float = rng.gen_range(-40.0, 1.3e5);
                                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~

在同一页面(上面)上有另一个例子(如下所示)可以工作.然而,它并没有完全符合我的要求,尽管我可以适应它. …

请注意,此问题是指Rust 1.0之前的Rust版本.虽然语法已经改变,但这些概念仍然有效.

您可以使用拥有的指针轻松实现仅转发链接列表,例如:

struct Node<T> {
  next: Option<~Node<T>>,
  data: T
}

但是,想象一下,如果您想要有效地实现支持四种基本操作的队列:

• push:添加到列表的末尾
• pop:从列表末尾删除并返回
• unshift:添加到列表的前面
• shift:从列表末尾删除并返回

在具有普通指针的语言中,您可以使用双向链表实现此操作,并使用根对象存储first和last指向列表中的第一个和最后一个元素.

我看不出你如何在Rust中实现它.

我可以模糊地猜测你会使用一堆引用,或许类似于:

struct Node<T> {
  next: Option<&Node<T>>,
  prev: Option<&Node<T>>,
  data: T
}

...但我看不出你如何管理这些变量的生命周期范围.

任何人都可以指出我的方向,或类似的例子涉及对象之间的引用复杂的生命周期？

(这种代码风格的另一个典型例子是观察者模式,其中许多对象必须将事件更新发布到单个位置,例如.UINode<> ---- EventObserver<> ---- EventCore<> ---- UINodes;多个对象一个复杂的层次结构共享指针,其中事件从叶节点传播到某个核心,然后被推送到不同的叶节点)

使用今天的Rust每晚,以下代码不再编译:

#[derive(Show)]
enum S {
    A,
    B
}

fn main() {
    println!("{}", S::A);
}

相反,它给我以下错误消息:

error: the trait `core::fmt::String` is not implemented for the type `S`

有没有办法得到旧的行为？当然,不需要为每种类型手动实现这一点.

本教程展示了一些非常基本的模式匹配示例,例如匹配整数以模拟c风格的switch语句.本教程还演示了如何对元组类型和解构结构进行基本的解构.

看起来应该可以在矢量上进行模式匹配,但是我无法找到它的正确语法,我还没有找到它的任何例子.

例如,在Haskell中,您可以轻松地对列表进行构造:

foldr :: (a -> b -> b) -> b -> [a] -> b
foldr func initValue []     = initValue
foldr func initValue (x:xs) = func initValue $ foldr initValue func xs

所以,看一个粗略的翻译,能够这样做会很高兴:

fn foldr<A, B>(func: fn(A, B) -> B,
               initValue: B,
               vals: [A]) -> B {
  alt vals {
    [] { ret initValue; }
    _  {
      let h = vec::head(vals),
          t = vec::tail(vals);
      ret foldr(func, func(initValue, h), t);
    }
  }
}

注意:我知道你可以在这里使用if语句,我只是将它作为矢量模式匹配的一个例子.

目前返回:

patterns.rs:10:4: 10:5 …

编者注:此问题中的代码早于Rust 1.0.此代码的等效现代版本按原样编译.

我还在学习Rust的步骤,并对以下内容感到惊讶.

我无法理解为什么这段代码会编译:

use std::iter::AdditiveIterator;

fn main() {

    let range = [1,2,3,4,5,6,7,8,9];
    let sum = range.iter().map(|&x| x * x).filter(|&x| x % 2 == 0).sum();

    println!("{}", sum);
}

虽然这不是:(只是向上移动.iter())

use std::iter::AdditiveIterator;

fn main() {

    let range = [1,2,3,4,5,6,7,8,9].iter();
    let sum = range.map(|&x| x * x).filter(|&x| x % 2 == 0).sum();

    println!("{}", sum);
}

这会导致此错误:

test.rs:5:17: 5:36 error: borrowed value does not live long enough
test.rs:5     let range = [1,2,3,4,5,6,7,8,9].iter();
                          ^~~~~~~~~~~~~~~~~~~

我确定它与Rust作用域等有关,但是我不确定我是如何通过将方法调用移动到另一行来产生影响的.

Rust有套接字或网络库吗？net标准库文档中的页面似乎只包含与地址相关的功能.