반복자 체인의 추출 체인이 도우미 함수를 호출합니다.

Question

현재 중복 된 일련의 반복 된 반복기 호출 (.lines().map(...).filter(...))을 캡슐화하는 함수를 작성하려고합니다. 컴파일 할 때 형식 서명을 알아낼 수 없습니다. Rust에 대해 이것이 불가능하거나 고도로 독창적이지 않다면, 나는 관용적 접근을위한 제안에 대해 개방적이다.

use std::fs; 
use std::io; 
use std::io::prelude::*; 
use std::iter; 

const WORDS_PATH: &str = "/usr/share/dict/words"; 

fn is_short(word: &String) -> bool { 
    word.len() < 7 
} 

fn unwrap(result: Result<String, io::Error>) -> String { 
    result.unwrap() 
} 

fn main_works_but_code_dupe() { 
    let file = fs::File::open(WORDS_PATH).unwrap(); 
    let reader = io::BufReader::new(&file); 
    let count = reader.lines().map(unwrap).filter(is_short).count(); 
    println!("{:?}", count); 

    let mut reader = io::BufReader::new(&file); 
    reader.seek(io::SeekFrom::Start(0)); 
    let sample_size = (0.05 * count as f32) as usize; // 5% sample 

    // This chain of iterator logic is duplicated 
    for line in reader.lines().map(unwrap).filter(is_short).take(sample_size) { 
     println!("{}", line); 
    } 
} 

fn short_lines<'a, T> 
    (reader: &'a T) 
    -> iter::Filter<std::iter::Map<std::io::Lines<T>, &FnMut(&str, bool)>, &FnMut(&str, bool)> 
    where T: io::BufRead 
{ 
    reader.lines().map(unwrap).filter(is_short) 
} 

fn main_dry() { 
    let file = fs::File::open(WORDS_PATH).unwrap(); 
    let reader = io::BufReader::new(&file); 
    let count = short_lines(reader).count(); 
    println!("{:?}", count); 

    // Would like to do this instead: 
    let mut reader = io::BufReader::new(&file); 
    reader.seek(io::SeekFrom::Start(0)); 
    let sample_size = (0.05 * count as f32) as usize; // 5% sample 
    for line in short_lines(reader).take(sample_size) { 
     println!("{}", line); 
    } 
} 


fn main() { 
    main_works_but_code_dupe(); 
} 

Answer 1

나는이 컴파일 얻을 수있는 유형의 서명을 알아낼 수 없습니다.

컴파일러 은을 말했습니다.

error[E0308]: mismatched types 
    --> src/main.rs:35:5 
    | 
35 |  reader.lines().map(unwrap).filter(is_short) 
    |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected reference, found fn item 
    | 
    = note: expected type `std::iter::Filter<std::iter::Map<_, &'a for<'r> std::ops::FnMut(&'r str, bool) + 'a>, &'a for<'r> std::ops::FnMut(&'r str, bool) + 'a>` 
       found type `std::iter::Filter<std::iter::Map<_, fn(std::result::Result<std::string::String, std::io::Error>) -> std::string::String {unwrap}>, for<'r> fn(&'r std::string::String) -> bool {is_short}>` 

이제는 직접 붙여 넣기 만하면됩니다. _ 유형을 이미 가지고있는 실제 유형으로 바꿔야합니다 (이미 맞았 기 때문에 버렸습니다). 둘째, {unwrap} 및 {is_short} 비트를 삭제해야합니다. 그것들은 함수 항목이 고유 한 유형을 가지고 있기 때문에 컴파일러가 주석을 달기 때문입니다. 슬프게도, 당신은 실제로 이러한 형식을 쓸 수 없습니다.

다시 컴파일하고 ...

error[E0308]: mismatched types 
    --> src/main.rs:35:5 
    | 
32 |  -> std::iter::Filter<std::iter::Map<std::io::Lines<T>, fn(std::result::Result<std::string::String, std::io::Error>) -> std::string::String>, for<'r> fn(&'r std::string::String) -> bool> 
    |   -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- expected `std::iter::Filter<std::iter::Map<std::io::Lines<T>, fn(std::result::Result<std::string::String, std::io::Error>) -> std::string::String>, for<'r> fn(&'r std::string::String) -> bool>` because of return type 
... 
35 |  reader.lines().map(unwrap).filter(is_short) 
    |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn pointer, found fn item 
    | 
    = note: expected type `std::iter::Filter<std::iter::Map<_, fn(std::result::Result<std::string::String, std::io::Error>) -> std::string::String>, for<'r> fn(&'r std::string::String) -> bool>` 
       found type `std::iter::Filter<std::iter::Map<_, fn(std::result::Result<std::string::String, std::io::Error>) -> std::string::String {unwrap}>, for<'r> fn(&'r std::string::String) -> bool {is_short}>` 

나는 기능 항목에 대해 고유 한 유형이 말을 기억 하는가? 그래, 그거야. 을 수정하려면을 함수 항목에서 함수 포인터로 캐스팅합니다. 우리는 캐스팅 할 내용을 지정할 필요조차 없습니다. 컴파일러가 캐스팅을 수행하기를 원한다는 것을 알리면됩니다.

fn short_lines<'a, T> 
    (reader: &'a T) 
    -> std::iter::Filter<std::iter::Map<std::io::Lines<T>, fn(std::result::Result<std::string::String, std::io::Error>) -> std::string::String>, for<'r> fn(&'r std::string::String) -> bool> 
    where T: io::BufRead 
{ 
    reader.lines().map(unwrap as _).filter(is_short as _) 
} 

error[E0308]: mismatched types 
    --> src/main.rs:41:29 
    | 
41 |  let count = short_lines(reader).count(); 
    |        ^^^^^^ expected reference, found struct `std::io::BufReader` 
    | 
    = note: expected type `&_` 
       found type `std::io::BufReader<&std::fs::File>` 
    = help: try with `&reader` 

다시 말하지만, 컴파일러는 무엇을 정확히 알려줍니다.

error[E0507]: cannot move out of borrowed content 
    --> src/main.rs:35:5 
    | 
35 |  reader.lines().map(unwrap as _).filter(is_short as _) 
    |  ^^^^^^ cannot move out of borrowed content 

오른쪽 당신이 잘못 입력 short_lines의을 가지고 있기 때문에, 그건 ... 변화를 확인합니다. 한 번 더 변경 :

fn short_lines<T> 
    (reader: T) 
    -> std::iter::Filter<std::iter::Map<std::io::Lines<T>, fn(std::result::Result<std::string::String, std::io::Error>) -> std::string::String>, for<'r> fn(&'r std::string::String) -> bool> 
    where T: io::BufRead 
{ 
    reader.lines().map(unwrap as _).filter(is_short as _) 
} 

이제 모든 사항을 경고해야합니다.

요약하면 컴파일러 메시지를 읽으십시오. 유용합니다.

Answer 2

나는 그것에게 간단한 방법으로하고 좋을 것 - 벡터에 반복자를 수집을 :

use std::fs; 
use std::io; 
use std::io::prelude::*; 

const WORDS_PATH: &str = "/usr/share/dict/words"; 

fn main() { 
    let file = fs::File::open(WORDS_PATH).unwrap(); 
    let reader = io::BufReader::new(&file); 
    let short_lines = reader.lines() 
          .map(|l| l.unwrap()) 
          .filter(|l| l.len() < 7) 
          .collect::<Vec<_>>(); // the element type can just be inferred 
    let count = short_lines.len(); 
    println!("{:?}", count); 

    let sample_size = (0.05 * count as f32) as usize; // 5% sample 

    for line in &short_lines[0..sample_size] { 
     println!("{}", line); 
    } 
}