小编nee*_*tza的帖子

我正在尝试实现一个"多态" Input枚举,它隐藏我们是从文件还是从stdin读取.更具体地说,我正在尝试构建一个枚举,它将有一个lines方法,该方法将"委托"该调用转换为File包含在a BufReader或a中StdInLock(两者都具有该lines()方法).

这是枚举:

enum Input<'a> {
    Console(std::io::StdinLock<'a>),
    File(std::io::BufReader<std::fs::File>)
}

我有三种方法:

• from_arg 通过检查是否提供了参数(文件名)来判断我们是从文件还是从stdin读取,
• file用a包装文件BufReader,
• console 用于锁定标准输入.

实施:

impl<'a> Input<'a> {
    fn console() -> Input<'a> {
        Input::Console(io::stdin().lock())
    }

    fn file(path: String) -> io::Result<Input<'a>> {
        match File::open(path) {
            Ok(file) => Ok(Input::File(std::io::BufReader::new(file))),
            Err(_) => panic!("kita"),
        }
    }

    fn from_arg(arg: Option<String>) -> io::Result<Input<'a>> {
        Ok(match arg {
            None => Input::console(),
            Some(path) => try!(Input::file(path)),
        })
    }
}

据我所知,我必须实现这两个BufRead和Read特征才能发挥作用.这是我的尝试: …

我有一个小的Clojure消费者/发布者接收消息,处理它们并将它们发送给其他消费者,所有这些都通过RabbitMQ.

我已经定义了一个消息处理程序,它在一个单独的线程中处理消息(与主线程分开).从下面的代码中可以看出,线程同步接收和发送消息,所有这些都发生在由lcm/subscribe函数启动的事件循环中.

那么,问题是,创建这些同步消息处理程序的N大小线程池的"Clojure方法"是什么？我想非Clojure方法是通过Java interop手动生成许多线程.

另外,考虑到处理不是CPU密集型的,那会加速消息处理吗？将这些消息处理程序设置为异步会不会更好 - 考虑到发布时间比处理时间更长？

最后,我将如何衡量这些竞争方法的性能(我来自Ruby/Javascript世界,那里没有任何多线程)？

注意:我知道所有这一切都可以通过横向扩展和产生更多JVM进程来监听消息总线来避免,但由于应用程序将部署在Heroku上,我想在每个dyno中使用尽可能多的资源/处理.

(defn message-handler
  [ch metadata ^bytes payload]
  (let [msg (json/parse-string (String. payload "UTF-8"))
        processed-message (process msg)] 
    (lb/publish ch "e.events" "" processed-message)))

(defn -main
  [& args]
  (let [conn          (rmq/connect {:uri (System/getenv "MSGQ")})
        ch            (lch/open conn)
        q-name        "q.events.tagger"
        e-sub-name    "e.events.preproc"
        e-pub-name    "e.events"
        routing-key   "tasks.taggify"]
    (lq/declare ch q-name :exclusive false :auto-delete false)
    (le/declare ch e-pub-name "fanout" :durable false)
    (lq/bind ch q-name e-sub-name :routing-key routing-key)
    (.start (Thread. (fn []
                       (lcm/subscribe ch q-name message-handler …

我正在尝试读取和解析Rust中的文本文件.每一行都是有符号整数.我能够使用for line in lines迭代来做到这一点,但我无法用一个iter().map(|l| ...)单行程来做.我得到了一个

expected `&core::result::Result<collections::string::String, std::io::error::Error>`,
found `core::result::Result<_, _>`

当我尝试模式匹配Ok(s) => match s.parse()但我无法深入了解我做错了什么.整个例子如下.底部的代码是产生错误的代码.

谁能说出我做错了什么？

use std::error::Error;
use std::fs::File;
use std::io::BufReader;
use std::io::prelude::*;
use std::path::Path;

fn main() {
    // Create a path to the desired file
    let path = Path::new("input/numbers.txt");
    let display = path.display();

    // Open the path in read-only mode, returns `io::Result<File>`
    let file = match File::open(&path) {
        // The `description` method of `io::Error` returns a string that describes the error
        Err(why) …

我正在尝试用 Rust 实现一个简单的 REPL 计算器，但我到处碰壁。

我在迭代硬编码字符串时消耗字符。当我点击数字字符时，我想将控制权传递给一个函数，该函数将消耗该数字的其余部分（假设该数字有多于一位数字）并返回该数字，并将其转换为整数。

Chars我在将迭代器传递给函数时遇到问题。我收到的错误是use of moved value: 'iter'.

我知道我不能改变我给别人的东西 - 其所有权已移动的东西 - 但我不知道有任何其他方法可以做到这一点，特别是因为 Chars 迭代器是不可复制的。

#[derive(Clone, Debug)]
enum Token {
    Addition,
    Substraction,
    Multiplication,
    Division,
    Integer(i32),
    Error,
}

fn consume_number(mut iter: std::str::Chars) -> Option<i32> {
    while let Some(item) = iter.next() {
        println!("{:?}", item);
    }

    return Some(1337);
}

fn tokenize(line: &str) -> Vec<Token> {
    let mut iter = line.chars();
    let mut tokens = Vec::new();
    let mut token;

    while let Some(c) = iter.next() {
        if c.is_whitespace() { …

我在一个我正在研究的S​​cheme解释器中找到了下面的类型别名.在评估AST时,它将功能识别为本机支持的功能或用户定义的功能.我理解Enum定义的第二部分,但第一部分使我无法理解.

pub enum Function {
    Native(ValueOperation),
    Scheme(Vec<String>, Vec<Value>, Rc<RefCell<Environment>>),
}


type ValueOperation = fn(&[Value], Rc<RefCell<Environment>>) -> Result<Value, RuntimeError>;

这种类型的别名如何工作？这个定义是否说a ValueOperation只是函数签名的简写？我无法在官方文档/书籍中找到任何关于这个成语的提及.

为函数签名定义类型别名的目的是什么？你能用它"做什么"？它是某种函数指针吗？