2014-10-12 33 views
6

में बजाय एक सरल इटरेटर इंटरफ़ेस रिटर्निंग एक मानचित्र की मैं इस लिखने के लिए करना चाहते हैं:जंग

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

लेकिन अगर मैं ऐसा, मैं इस त्रुटि मिलती है:

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

अगर मैं बजाय, पूर्ण इंटरफ़ेस लिखें, यह संकलित करता है:

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) 
} 

क्या सरल इंटरफ़ेस वापस करने का कोई तरीका है?

+0

इटरेटर एक विशेषता है और नहीं एक प्रकार है। मुझे जंग के बारे में ज्यादा जानकारी नहीं है लेकिन मुझे लगता है कि आपको इसे बॉक्स में पैक करना होगा। अनबॉक्स किए गए अमूर्त प्रकारों को वापस करने के लिए हमें इसकी आवश्यकता है: https://github.com/rust-lang/rfcs/pull/105 – Simon

उत्तर

6

वर्तमान में Iterator<T> जैसे अमूर्त प्रकार को वापस करने का कोई तरीका नहीं है, जैसा कि आप एक चर के प्रकार के रूप में असाइन नहीं कर सकते हैं (let x: Iterator<uint>; उसी कारण से संकलित नहीं होगा)।

यह has been discussed और निश्चित रूप से वांछित है; जब यह किया जाता है तो यह शायद fn fibs() -> impl Iterator<uint> रूप में होगा, लेकिन आप अभी तक ऐसा नहीं कर सकते हैं।

+0

ऐसा प्रतीत होता है कि समस्या बंद कर दी गई है: https://github.com/rust-lang/rfcs/ खींच/105। क्या आरएफसी दूसरे द्वारा छेड़छाड़ की गई है? –

+0

मुझे विश्वास नहीं है कि यह इस पल के लिए रहा है, लेकिन यह किसी बिंदु पर होगा। –

+0

अच्छी खबर, एक नया है: https://github.com/rust-lang/rfcs/issues/518 –

1

@ChrisMorgan के रूप में कहा, अब के लिए आप एक सार प्रकार वापस नहीं कर सकते हैं। यदि आप एक सार्वजनिक एपीआई बना रहे हैं और iterate और map के विशिष्ट कार्यान्वयन पर बहुत अधिक निर्भर करने से बचना चाहते हैं, तो आप रिटर्न प्रकार को अपनी खुद की संरचना में समाहित कर सकते हैं (जो कि एसडी लाइब्रेरी में संग्रहों को कम या कम करता है)।

कुछ की तरह:

// 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); 
    } 
} 
+0

धन्यवाद! मुझे लगता है कि स्विफ्ट एक ही तरह की चीज करता है लेकिन सामान्य रूप से AnySequence https://developer.apple.com/library/tvos/documentation/Swift/Reference/Swift_AnySequence_Structure/index.html के साथ –