    "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;
        }

    }