I changed the previous version of LazyList to MutableLazyList, and made an new LazyList in it's place that's immutatble. It's optumized to only call one evaluation once, this means previous versions are evaluated as well if they weren't already evaluated, incase they're still in use and haven't been evaluated yet but will be used in the future. This optimization required me compromise and put a bit of mutatblity under the hood of the new LazyList class. Once a lazy list is evaluated is then set to null to allow garbage collect to pick it up if isn't in use anywhere else, also until garbage collection is called it will be sitting in the background so that's also a negitiave aspect. And yes this means this new LazyList does not use the EvaluationComposer it instead stores a single final evaluation as there's only one evaluation pre instance, and everytime a command method is called it return a new version of LazyList through a private constructor that takes a refence to the previous version (which will otherwise be null in all the other constructors), and a ListEvaluator, which would otherwise be a lambda that takes a list and does nothing with it. This all just means it is some what not as impressive as the Mutatble LazyList but can be used in more functional contexts.