"A `Map` implementation that wraps an `Iterable` of entries. All operations, such as lookups, size, etc. are performed on the `Iterable`." by ("Enrique Zamudio") shared class LazyMap<out Key,out Item>({<Key->Item>*} entries) satisfies Map<Key,Item> given Key satisfies Object given Item satisfies Object { shared actual <Key->Item>? first => entries.first; shared actual <Key->Item>? last => entries.last; shared actual LazyMap<Key, Item> clone => this; shared actual Integer size => entries.size; shared actual Item? get(Object key) => entries.find((Key->Item e) => e.key==key)?.item; shared actual Iterator<Key->Item> iterator() => entries.iterator(); shared actual default Boolean equals(Object that) { if (is Map<Object,Object> that) { if (that.size==size) { for (entry in this) { if (exists item = that[entry.key]) { if (item==entry.item) { continue; } } return false; } else { return true; } } } return false; } shared actual default Integer hash { variable Integer hashCode = 1; for(elem in entries) { hashCode *= 31; hashCode += elem.hash; } return hashCode; } }