Tornando un'interfaccia Iterator più semplice invece di una mappa a Rust

Question

mi piacerebbe scrivere questo:

fn fibs() -> std::iter::Iterator<int> { 
    return std::iter::iterate((1i, 1i), |(a, b)| { (b, a + b) }).map(|(a, _)| a) 
} 

Ma se lo faccio, ottengo questo errore:

error: explicit lifetime bound required 
fn fibs() -> std::iter::Iterator<int> { 
      ^^^^^^^^^^^^^^^^^^^^^^^^ 

Se, invece ho scrivere l'interfaccia completa, compila:

fn fibs() -> std::iter::Map<'static, (int, int), int, std::iter::Iterate<'static, (int, int)>> { 
    return std::iter::iterate((1i, 1i), |(a, b)| { (b, a + b) }).map(|(a, _)| a) 
} 

C'è un modo per restituire l'interfaccia più semplice?

Answer 1

Non esiste attualmente alcun modo per restituire un tipo astratto come Iterator<T>, così come non è possibile assegnarlo come tipo di variabile (let x: Iterator<uint>; non verrà compilato per gli stessi motivi).

Questo has been discussed ed è sicuramente desiderato; quando è fatto, probabilmente sarà nella forma fn fibs() -> impl Iterator<uint>, ma non è ancora possibile farlo.

Answer 2

come ha detto @ChrisMorgan, per ora non è possibile restituire un tipo astratto. Se si sta creando un'API pubblica e si desidera evitare di dipendere troppo dall'implementazione specifica di iterate e map, è possibile incapsulare il tipo restituito nella propria struct (che è più o meno ciò che fanno le raccolte nella stessa libreria std).

Qualcosa di simile:

// updated to rustc 0.13.0-nightly (2015-01-02) 
use std::iter::{Map, iterate, Unfold}; 

type Fibs = Map<(int, int), int, Unfold<(int, int), 
    (fn((int, int)) -> (int, int), Option<(int, int)>, bool), 
    fn(&mut (fn((int, int)) -> (int, int), Option<(int, int)>, bool)) -> 
     Option<(int, int)>>, fn((int, int)) -> int>; 

struct Fibs2 { 
    iter: Fibs, 
} 

impl Fibs2 { 
    fn iter() -> Fibs2 { 
     fn inner((a, b): (int, int)) -> (int, int) { (b, a + b) } 
     let in_fn = inner as fn((int, int)) -> (int, int); 

     fn first((a, _): (int, int)) -> int { a } 
     let p_first = first as fn((int, int)) -> int; 

     Fibs2{ iter: iterate((1i, 1i), in_fn).map(p_first) } 
    } 
} 

impl Iterator<int> for Fibs2 { 
    fn next(&mut self) -> Option<int> { 
     self.iter.next() 
    } 
} 

fn main() { 
    for fib_n in Fibs2::iter().take(10) { 
     println!("{}", fib_n); 
    } 
}