借用的值活得不够长（BufReader行（）到String的迭代器）

Question

使用以下示例代码：

use std::fs::{File};
use std::io::{BufRead, BufReader};
use std::path::Path;

type BoxIter<T> = Box<Iterator<Item=T>>;

fn tokens_from_str<'a>(text: &'a str) 
-> Box<Iterator<Item=String> + 'a> {
    Box::new(text.lines().flat_map(|s|
        s.split_whitespace().map(|s| s.to_string())
    ))
}

// Returns an iterator of an iterator. The use case is a very large file where
// each line is very long. The outer iterator goes over the file's lines.
// The inner iterator returns the words of each line.
pub fn tokens_from_path<P>(path_arg: P) 
-> BoxIter<BoxIter<String>>
where P: AsRef<Path> {
    let reader = reader_from_path(path_arg);
    let iter = reader.lines()
        .filter_map(|result| result.ok())
        .map(|s| tokens_from_str(&s));
    Box::new(iter)
}

fn reader_from_path<P>(path_arg: P) -> BufReader<File>
where P: AsRef<Path> {
    let path = path_arg.as_ref();
    let file = File::open(path).unwrap();
    BufReader::new(file)
}

我收到以下编译器错误消息：

rustc 1.18.0 (03fc9d622 2017-06-06)
error: `s` does not live long enough
  --> <anon>:23:35
   |
23 |         .map(|s| tokens_from_str(&s));
   |                                   ^- borrowed value only lives until here
   |                                   |
   |                                   does not live long enough
   |
   = note: borrowed value must be valid for the static lifetime...

我的问题是：

>

如何解决这个问题（如果可能，在不改变函数签名的情况下？）

对更好的函数参数和返回值有什么建议吗？

Answer 1

这里的问题是您确实使用to_string（）将每个项目转换为拥有的值，这是懒惰地完成的。因为它是懒惰的，所以使用to_string之前的值（a

这里最简单的解决方案是删除迭代器这一部分的延迟计算，并在分配行后立即分配所有令牌。这不会那么快，而且会涉及额外的分配，但与您当前的功能相比变化最小，并保持相同的签名：

// Returns an iterator of an iterator. The use case is a very large file where
// each line is very long. The outer iterator goes over the file's lines.
// The inner iterator returns the words of each line.
pub fn tokens_from_path<P>(path_arg: P) -> BoxIter<BoxIter<String>>
where
    P: AsRef<Path>
{
    let reader = reader_from_path(path_arg);
    let iter = reader.lines()
        .filter_map(|result| result.ok())
        .map(|s| {
            let collected = tokens_from_str(&s).collect::<Vec<_>>();

            Box::new(collected.into_iter()) as Box<Iterator<Item=String>>
        });

    Box::new(iter)
}

此解决方案适用于任何较小的工作负载，并且它只会同时为该行分配大约两倍的内存。会有性能损失，但除非您有10mb的行，否则这可能无关紧要。

如果您选择了这个解决方案，我建议您将令牌的函数签名从_path更改为直接返回一个BoxIter

pub fn tokens_from_path<P>(path_arg: P) -> BoxIter<String>
where
    P: AsRef<Path>
{
    let reader = reader_from_path(path_arg);
    let iter = reader.lines()
        .filter_map(|result| result.ok())
        .flat_map(|s| {
            let collected = tokens_from_str(&s).collect::<Vec<_>>();

            Box::new(collected.into_iter()) as Box<Iterator<Item=String>>
        });

    Box::new(iter)
}

原始代码不起作用，因为您试图将借词返回到一个不返回的字符串。

我们可以通过返回字符串来解决这个问题——只是隐藏在不透明的API后面。这与breeden的解决方案非常相似，但在执行上略有不同。

use std::fs::{File};
use std::io::{BufRead, BufReader};
use std::path::Path;

type BoxIter<T> = Box<Iterator<Item=T>>;

/// Structure representing in our code a line, but with an opaque API surface.
pub struct TokenIntermediate(String);

impl<'a> IntoIterator for &'a TokenIntermediate {
    type Item = String;
    type IntoIter = Box<Iterator<Item=String> + 'a>;

    fn into_iter(self) -> Self::IntoIter {
        // delegate to tokens_from_str
        tokens_from_str(&self.0)
    }
}

fn tokens_from_str<'a>(text: &'a str) -> Box<Iterator<Item=String> + 'a> {
    Box::new(text.lines().flat_map(|s|
        s.split_whitespace().map(|s| s.to_string())
    ))
}

// Returns an iterator of an iterator. The use case is a very large file where
// each line is very long. The outer iterator goes over the file's lines.
// The inner iterator returns the words of each line.
pub fn token_parts_from_path<P>(path_arg: P) -> BoxIter<TokenIntermediate>
where
    P: AsRef<Path>
{
    let reader = reader_from_path(path_arg);
    let iter = reader.lines()
        .filter_map(|result| result.ok())
        .map(|s| TokenIntermediate(s));

    Box::new(iter)
}

fn reader_from_path<P>(path_arg: P) -> BufReader<File>
where P: AsRef<Path> {
    let path = path_arg.as_ref();
    let file = File::open(path).unwrap();
    BufReader::new(file)
}

正如您所注意到的，tokens\u from_str没有区别，而tokens\u from_path只返回这个不透明的TokenIntermediate结构。这将与原始解决方案一样可用，它所做的只是将中间字符串值的所有权推给调用者，以便调用者可以迭代其中的令牌。

Answer 2

免责声明：框架挑战

处理大文件时，最简单的解决方案是使用内存映射文件。

也就是说，你告诉操作系统你希望整个文件在内存中可以被访问，并且由它来处理文件的部分在内存中的分页和从内存中的分页。

一旦关闭，您的整个文件就可以作为访问

它可能并不总是最快的解决方案；这当然是最简单的。

Answer 3

一个问题是.split_whitespace（）接受引用，并且不拥有其内容。因此，当您尝试使用拥有的拥有对象构造SplitWhitesspace对象时（当您调用. map（|s|tokens_from_str（

use std::fs::File;
use std::io::{BufRead, BufReader};
use std::path::Path;
use std::iter::IntoIterator;
use std::str::SplitWhitespace;

pub struct SplitWhitespaceOwned(String);

impl<'a> IntoIterator for &'a SplitWhitespaceOwned {
    type Item = &'a str;
    type IntoIter = SplitWhitespace<'a>;
    fn into_iter(self) -> Self::IntoIter {
        self.0.split_whitespace()
    }
}

// Returns an iterator of an iterator. The use case is a very large file where
// each line is very long. The outer iterator goes over the file's lines.
// The inner iterator returns the words of each line.
pub fn tokens_from_path<P>(path_arg: P) -> Box<Iterator<Item = SplitWhitespaceOwned>>
    where P: AsRef<Path>
{
    let reader = reader_from_path(path_arg);
    let iter = reader
        .lines()
        .filter_map(|result| result.ok())
        .map(|s| SplitWhitespaceOwned(s));
    Box::new(iter)
}

fn reader_from_path<P>(path_arg: P) -> BufReader<File>
    where P: AsRef<Path>
{
    let path = path_arg.as_ref();
    let file = File::open(path).unwrap();
    BufReader::new(file)
}

fn main() {
    let t = tokens_from_path("test.txt");

    for line in t {
        for word in &line {
            println!("{}", word);
        }
    }
}