HKT (Higher kinded type) 지원없이 Rust에서 일반 구조를 만들려면 어떻게해야합니까?

Question

다른 구문 분석 함수를 전달하고 다른 Iteratee을 얻을 수 있도록 Iteratee 구조를 일반화하려고합니다.

use std::io::{BufRead, BufReader}; 
use std::str::{from_utf8, Utf8Error}; 

#[derive(PartialEq, Debug)] 
struct Cat<'a> { 
    name: &'a str, 
} 

fn parse<'a>(slice: &'a [u8]) -> Result<Cat<'a>, Utf8Error> { 
    from_utf8(slice).map(|name| Cat { name: name }) 
} 

struct Iteratee<R> 
    where R: BufRead + Sized 
{ 
    read: R, 
} 

impl<R> Iteratee<R> 
    where R: BufRead + Sized 
{ 
    fn next<'a, F>(&'a mut self, fun: F) 
     where F: Fn(Option<Result<Cat<'a>, Utf8Error>>) ->() + Sized 
    { 
     let slice = self.read.fill_buf().unwrap(); 
     fun(Some(parse(slice))) 
     //  ^^^^^^^^^^^ How do I pull 'parse' up as a function of Iteratee 
    } 
} 

fn main() { 
    let data = &b"felix"[..]; 
    let read = BufReader::new(data); 
    let mut iterator = Iteratee { read: read }; 
    iterator.next(|cat| assert_eq!(cat.unwrap().unwrap(), Cat { name: "felix" })); 
} 

이 그것이 일반적인 제작에서 내 시도,하지만 난이 함수에 대한 참조 또는 폐쇄를 전달하거나 함께 IterateeFun을 만들 수 없습니다 :이 작품이 아닌 일반 버전입니다.

struct IterateeFun<R, P, T> 
    where R: BufRead + Sized, 
      P: Fn(&[u8]) -> (Result<T, Utf8Error>) + Sized 
{ 
    read: R, 
    parser: P, 
} 

impl<R, P, T> IterateeFun<R, P, T> 
    where R: BufRead + Sized, 
      P: Fn(&[u8]) -> (Result<T, Utf8Error>) + Sized 
{ 
    fn next<'a, F>(&'a mut self, fun: F) 
     where F: Fn(Option<Result<T, Utf8Error>>) ->() + Sized 
    { 
     let slice = self.read.fill_buf().unwrap(); 
     fun(Some((self.parser)(slice))) 
    } 
} 


fn main() { 
    let data = &b"felix"[..]; 
    let read = BufReader::new(data); 
    let mut iterator = IterateeFun { 
     read: read, 
     parser: parse, // What can I put here? 
     // I've tried a closure but then I get error[E0495]/ lifetime issues 
    }; 

    iterator.next(|cat| assert_eq!(cat.unwrap().unwrap(), Cat { name: "felix" })); 
} 

그림과 같이 함수에 함수를 전달하는 방법을 알고 싶습니다. 아니면 내가 대신이 특성으로해야합니까?

Answer 1

대부분의 문제와 마찬가지로 나는 다른 수준의 간접 참조가 필요했습니다. 더 높은 kinded types (HKT)가 분명히 도움이 될 것이지만 실제로는 파싱 함수와 평생 매개 변수를 연결할 수 있어야합니다. user4815162342 및 Streamer에서 영감을

는 내가 관련 유형이 개 특성 Iteratee<'a> 및 Parser<'a> 각을 만들 수 있습니다 실현하고 내가 그들을 결합 구현을 만들 때 나는 나에게 HKTs의 양식을 제공하기 위해 관련 유형을 결합 할 수있을 것입니다 :

는

trait Parser<'a> { 
    type Output: 'a; 

    fn parse(&self, &'a [u8]) -> Result<Self::Output, Utf8Error>; 
} 

struct CatParser; 

impl<'a> Parser<'a> for CatParser{ 
    type Output = Cat<'a>; 

    fn parse(&self, slice: &'a [u8]) -> Result<Self::Output, Utf8Error> { 
     parse(slice) 
    } 
} 

trait Iteratee<'a> { 
    type Item: 'a; 

    fn next<F>(&'a mut self, fun: F) where F: Fn(Option<Self::Item>) ->() + Sized; 
} 

struct IterateeParser<R, P> { 
    read: R, 
    parser: P, 
} 

impl<'a, R, P> Iteratee<'a> for IterateeParser<R,P> where R: BufRead + Sized, P: Parser<'a> { 
    type Item = Result<P::Output, Utf8Error>; 
    //     ^^^^^^^^^ This is the magic! 

    fn next<F>(&'a mut self, fun: F) where F: Fn(Option<Self::Item>) ->() + Sized { 
     let slice = self.read.fill_buf().unwrap(); 
     fun(Some(self.parser.parse(slice))) 
    } 
} 

fn main() { 
    let data = &b"felix"[..]; 
    let read = BufReader::new(data); 
    let mut iterator = IterateeParser { read: read, parser: CatParser }; 
    iterator.next(|cat| assert_eq!(cat.unwrap().unwrap(), Cat { name: "felix" })); 
} 

마법 라인은 공정 점은 심지어 올바른 용어가 내가 가지고있는 문제를 설명하기 위해 무엇 확실하지 않다 순간에,이다 type Item = Result<P::Output, Utf8Error>;