Có phải std :: iter :: FlatMap.clone() có thể không?

Question

tôi đang cố gắng để tạo ra tất cả các cặp có thể có của các mục trong một FlatMap:

possible_children.clone().flat_map(|a| possible_children.clone().map(|b| (a,b))) 

Để làm được điều này, tôi đang cố gắng để sao chép một FlatMap và tôi thấy trong tài liệu rằng FlatMap struct thực hiện một phương pháp clone . Nhưng dường như không thể tạo ra một FlatMap thỏa mãn các giới hạn đặc điểm.

Đây là lỗi Tôi nhận:

error: no method named `clone` found for type `std::iter::FlatMap<std::ops::Range<u16>, _, [closure@src/main.rs:30:47: 33:27]>` in the current scope 
    --> src/main.rs:37:66 
    | 
37 |   possible_children.clone().flat_map(|a| possible_children.clone().map(|b| (a,b))) 
    |                 ^^^^^ 
    | 
    = note: the method `clone` exists but the following trait bounds were not satisfied: `[closure@src/main.rs:30:47: 33:27] : std::clone::Clone` 

Nhìn vào tài liệu tôi thấy:

impl<I, U, F> Clone for FlatMap<I, U, F> 
    where F: Clone, I: Clone, U: Clone + IntoIterator, U::IntoIter: Clone 

và

impl<I, U, F> Iterator for FlatMap<I, U, F> 
    where F: FnMut(I::Item) -> U, I: Iterator, U: IntoIterator 

Dường như F bị ràng buộc bởi cả Clone đặc điểm và đặc tính FnMut, nhưng không phải là possibl e để có điều gì đó để triển khai cả hai FnMut và Clone.

Có vẻ lạ rằng một phương pháp sẽ tồn tại trong tài liệu không thể gọi được, vì vậy tôi phải thiếu điều gì đó.

Có thể ai đó vui lòng làm rõ cho tôi không?

MVCE:

fn main() { 
    let possible_children = (0..10).flat_map(|x| (0..10).map(|y| (x,y))); 

    let causes_error = possible_children.clone().flat_map(|a| 
     possible_children.clone().map(|b| (a,b)) 
    ).collect(); 

    println!("{:?}",causes_error); 
} 

Answer 1

Không có lý do cố hữu rằng một loại không thể thực hiện cả hai FnMut và Clone, nhưng có vẻ như vào lúc này đóng cửa không thực hiện Clone. Dưới đây là tóm tắt discussion about this from 2015. Tôi chưa tìm thấy bất kỳ cuộc thảo luận gần đây nào.

tôi đã có thể xây dựng ví dụ này, nơi một FlatMap được nhân bản bằng cách thực hiện FnMut trên struct của riêng tôi, mà đòi hỏi phải có tính năng ổn định, do đó, một trình biên dịch đêm (playground):

#![feature(unboxed_closures)] 
#![feature(fn_traits)] 
struct MyFun { 
    pub v: usize, 
} 

impl FnOnce<(usize,)> for MyFun { 
    type Output = Option<usize>; 
    extern "rust-call" fn call_once(self, args: (usize,)) -> Self::Output { 
     Some(self.v + 1 + args.0) 
    } 

} 

impl FnMut<(usize,)> for MyFun { 
    extern "rust-call" fn call_mut(&mut self, args: (usize,)) -> Self::Output { 
     self.v += 1; 
     if self.v % 2 == 0 { 
      Some(self.v + args.0) 
     } else { 
      None 
     } 
    } 
} 

impl Clone for MyFun { 
    fn clone(&self) -> Self { 
     MyFun{v: self.v} 
    } 
} 

fn main() { 
    let possible_children = (0..10).flat_map(MyFun{v:0}); 
    let pairs = possible_children.clone().flat_map(|x| possible_children.clone().map(move |y| (x,y))); 
    println!("possible_children={:?}", pairs.collect::<Vec<_>>()); 
} 

Answer 2

Bạn đang tạo Descartes sản phẩm của tập hợp các mục trong một trình lặp với một mục khác. Bạn có thể sử dụng số .cartesian_product() adaptor từ số itertools thùng cho điều đó.