Lifetime of dependent type cannot depend on the function

[uzytkownik]

(This might be partially related to issue #44950)

Currently dependent types lifetime must not depend on the lifetime of the iterator. This is problematic when the method of iteration might alter the structure but copy is expensive or impossible (I run into this while binding C API but this affects also database cursors etc.).

Here's an example of code which shows the issue ([u8; 4096] is just an example of expensive-to-copy data).

struct Handle {
    buf: *mut [u8; 4096]
}

struct Iter {
    buf: Box<[u8; 4096]>,
    hnd: Handle
}

unsafe fn fake_c_method_init(buf: *mut [u8; 4096]) -> Handle {
    Handle {
        buf: buf
    }
}

unsafe fn fake_c_method_next(hnd: &mut Handle) -> bool {
    (*hnd.buf)[0] += 1;
    true
}

impl Iter {
    fn new() -> Self {
        use std::borrow::BorrowMut;
        let mut buf = Box::new([0; 4096]);
        let hnd = unsafe {
            fake_c_method_init(buf.borrow_mut() as *mut [u8; 4096])
        };
        Iter {
            buf: buf,
            hnd: hnd
        }
    }

    fn next_fast(&mut self) -> Option<&[u8; 4096]> {
        use std::borrow::Borrow;
        if unsafe {fake_c_method_next(&mut self.hnd)} {
            Some(self.buf.borrow())
        } else {
            None
        }
    }
}

impl Iterator for Iter {
    type Item = [u8; 4096];
    fn next(&mut self) -> Option<Self::Item> {
        self.next_fast().map(|arr| {
            let mut res = [0; 4096];
            for i in 0..4096 {
                res[i] = arr[i];
            }
            res
        })
    }
}

This is even though in most cases a copy is not needed.

[sfackler]

You may be interested in https://docs.rs/streaming-iterator/0.1.2/streaming_iterator/.

This kind of thing is fundamentally incompatible with Iterator itself.

[XAMPPRocky]

Closing as inactionable.