小编Mat*_*ahl的帖子

阅读零成本抽象并查看生锈简介:一种具有高级抽象的低级语言我试图比较两种计算向量点积的方法:一种使用for循环,一种使用迭代器.

#![feature(test)]

extern crate rand;
extern crate test;

use std::cmp::min;

fn dot_product_1(x: &[f64], y: &[f64]) -> f64 {
    let mut result: f64 = 0.0;
    for i in 0..min(x.len(), y.len()) {
        result += x[i] * y[i];
    }
    return result;
}

fn dot_product_2(x: &[f64], y: &[f64]) -> f64 {
    x.iter().zip(y).map(|(&a, &b)| a * b).sum::<f64>()
}

#[cfg(test)]
mod bench {
    use test::Bencher;
    use rand::{Rng,thread_rng};
    use super::*;

    const LEN: usize = 30;

    #[test]
    fn test_1() {
        let x = [1.0, …

我正在玩 Tokio 和 Rust，作为一个例子，我正在尝试编写一个简单的 UDP 代理，它只会在一个套接字上接受 UDP 数据包并将其发送到多个其他目的地。但是，我偶然发现需要将接收到的数据包发送到多个地址的情况，并且不确定如何以惯用的方式做到这一点。

我有这么远的代码：

extern crate bytes;
extern crate futures;

use std::net::SocketAddr;
use tokio::codec::BytesCodec;
use tokio::net::{UdpFramed, UdpSocket};
use tokio::prelude::*;

fn main() {
    let listen_address = "127.0.0.1:4711".parse::<SocketAddr>().unwrap();
    let forwarder = {
        let socket = UdpSocket::bind(&listen_address).unwrap();
        let peers = vec![
            "192.168.1.136:4711".parse::<SocketAddr>().unwrap(),
            "192.168.1.136:4712".parse::<SocketAddr>().unwrap(),
        ];
        UdpFramed::new(UdpSocket::bind(&listen_address).unwrap(), BytesCodec::new()).for_each(
            move |(bytes, _from)| {
                // These are the problematic lines
                for peer in peers.iter() {
                    socket.send_dgram(&bytes, &peer);
                }
                Ok(())
            },
        )
    };

    tokio::run({
        forwarder
            .map_err(|err| println!("Error: {}", err))
            .map(|_| ())
    });
} …

我正在尝试在Go中编写一个扫描器来扫描延续线,并在返回之前清理该线,以便您可以返回逻辑线.因此,给定以下SplitLine函数(Play):

func ScanLogicalLines(data []byte, atEOF bool) (int, []byte, error) {
    if atEOF && len(data) == 0 {
        return 0, nil, nil
    }

    i := bytes.IndexByte(data, '\n')
    for i > 0 && data[i-1] == '\\' {
        fmt.Printf("i: %d, data[i] = %q\n", i, data[i])
        i = i + bytes.IndexByte(data[i+1:], '\n')
    }

    var match []byte = nil
    advance := 0
    switch {
    case i >= 0:
        advance, match = i + 1, data[0:i]
    case atEOF: 
        advance, match = len(data), data
    } …

我正在尝试编写一个宏来将一组规则扩展为执行令牌匹配的代码,但是在不导致宏扩展错误的情况下无法生成正确的代码.我知道我可以处理其他方式,但这里的关键问题不是如何解析令牌,而是如何编写一个可以递归扩展带有匹配臂的令牌树的宏.

我们的想法是,我们想要从字符串中读取一个令牌并将其打印出来.需要添加更多代码才能将其转换为更有用的代码,但此示例用于说明这种情况:

#[derive(Debug, PartialEq)]
enum Digit {
    One,
    Two,
    Three,
    Ten,
    Eleven,
}

#[test]
fn test1(buf: &str) {
    let buf = "111";
    let token = parse!(buf, {
        '1' => Digit::One,
        '2' => Digit::Two,
        '3' => Digit::Three,
    });
    assert_eq!(token, Some(Digit::One));
}

我们想从这个例子中生成的代码是:

fn test1(buf: &str) {
    let token = {
        let mut chars = buf.chars().peekable();
        match chars.peek() {
            Some(&'1') => {
                chars.next().unwrap();
                Digit::One
            }
            Some(&'2') => {
                chars.next().unwrap();
                Digit::Two
            }
            Some(&'3') => {
                chars.next().unwrap();
                Digit::Three
            }
            Some(_) | None => None, …

在尝试重载调用语法时,我引入了一个简单的缓存,可以缓存昂贵的计算结果.我对使用一段语法感到有点困惑.我将在问题之前逐步介绍代码.

缓存旨在使用如下:

fn fib(x: i32) -> i32 {
    if x < 2 { x } else { fib(x-1) + fib(x-2) }
}

fn main() {
    let mut cfib = Cache::new(fib);

    // Loop that repeats computation and extracts it from the cache
    // the second time.
    for x in 1..200 {
        let val = 5 * x % 40;
        println!("fibc({}) = {}", val, cfib(val));
    }
}

我们首先使用序言来启用尚未稳定的功能:

#![feature(fn_traits, unboxed_closures)]

use std::collections::HashMap;
use std::hash::Hash;

我们将缓存作为具有a HashMap和函数的结构引入以计算新值.

struct Cache<T, R> {
    cache: …