I don’t think this is that hard; you “just” need to construct the data structures as elements of an object-graph data structure, and then retrieve your data through an explicit thunk of the object-graph itself.
In lazy languages the object-graph data structure is implicit, but that doesn’t mean that the Rust version of the call site code needs to be any more verbose. It’s just the definitions of the data structures themselves that would be more unwieldy. (And you could probably build some generic lazy container types and mostly work with those.)
Think: what Objective-C does with autorelease-pool objects.
Why is that an issue?
If you can implement lazy finger trees with iterators I'd love to see it :)
Hiding the fact that a lazy value needs to be mutated to initialise it is a little more work (since a nice API lets the user treat the value as if it doesn’t need to be mutated), but is certainly possible.
It's not proper laziness as defined in Okasaki's thesis/book. One needs more complex things like lazy finger trees.
The language is not.
I don't think you can do everything in everything. Try working with lazy immutable data structures in Rust, for one.
Or look at Dart - now has "non-nullable types," monadic error handling (sort of), but of course the whole thing is on shaky foundations so what's it worth?