Можно полный пример?

Но хочу следать индексирование итеративным.

Зачем?

let mut top : &mut InfLazyList<T> = &mut self;

Не многовато ли? Разве let top = &mut self не достаточно?

top меняется в цикле. Без mut не будет меняться.

Первый раз вижу растовский код. Какой-то C++ вверх ногами.

Можно полный пример?

Сейчас это скорее абстрактная ситуация. Ранее я сталкивался с этим когда писал транслятор и там была рекурсивная проверка типов.

Зачем?

Ну епт! Потому что циклы более производительные чем рекурсия. Раст вроде как подается как высокопроизводительный. А автоматической развертки хвостовой рекурсии в циклы компилятор не умеет. Об этом как-то писали создатели, что там неопределенная ситуация с временем жизни может случиться.

«Если у тебя в из инструметов только молоток, все выглядит как гвоздь»(с)

Твой пример очень похож на «Problem case #4: mutating &mut references» из Nonlexical Lifetimes RFC. Попробуй workaround оттуда.

https://github.com/nikomatsakis/nll-rfc/blob/master/0000-nonlexical-lifetimes...

Спасибо за ссылку. Интересный гайд по lifetime. Вечером посмотрю.

Потому что циклы более производительные чем рекурсия.

Доу, я не так понял. Я подумал, что вы хотите использовать c-style циклы, а не итераторы.

struct InfLazyList<T> {
	head : T,
	tail : Lazy<InfLazyList<T>>
}

И как будет выглядеть инициализация структуры?

Ни как =) Ибо tail должен быть option

Например так

fn gen_fibs() -> USeq {
	fn rec(a : usize, b : usize) -> USeq {
		InfLazyList{head : a, tail : lazy!(rec(b, a+b))}
	}
	rec(1, 1)
}

Ну и lazy собсна в довесок

struct Lazy<T> {
	val : LazyVal<T>
}

enum LazyVal<T> {
	Forced(Box<T>),
	NotForced(Box<Fn()->T>),
	Nil
}

macro_rules! lazy {
	($expr:expr) => {
		Lazy {
			val : LazyVal::NotForced(Box::new(move||$expr)),
		}
	}
}

impl<T> Lazy<T> {
	fn force(&mut self) -> &mut T {
		match self.val {
			LazyVal::Forced(ref mut val) => return val,
			_ => ()
		}
		match mem::replace(&mut self.val, LazyVal::Nil) {
			LazyVal::NotForced(fnc) => {
				self.val = LazyVal::Forced(Box::new(fnc()));
				match self.val {
					LazyVal::Forced(ref mut val) => return val,
					_ => panic!()
				}
			},
			_ => panic!()
		}
	}
}

Попробуй

    fn index(&mut self, i: usize) -> &T {
        let mut top = self;
        for _ in 0..i {
            let top1 = top;
            top = top1.tail.force();
        }
        &top.head
    }

Самое оно. Спасибо.

Это и есть решение из RFC. Его скоро примут и уже не нужно будет создавать лишнюю переменную.

Полезная ссылка в тему, хотя многие её уже видели, я думаю: https://matthias-endler.de/2017/boxes-and-trees/

offtop

А вы случайно не знаете, что там комитет думает про box синтакс? Его стабилизировтаь собираются? Это который «box foo()» вместо «Box::new(foo())»

нет, про box я давно не слышал.

я думаю его не будут трогать пока не решат все проблемы с кастомными алокаторами и placement new.