    "A pair containing a _key_ and an associated value called
     the _item_. Used primarily to represent the elements of a
     [[Map]]. The type `Entry<Key,Item>` may be abbreviated
     `Key->Item`. An instance of `Entry` may be constructed
     using the `->` operator:

         String->Person entry = person.name->person;"
    by ("Gavin")
    tagged("Collections")
    shared final serializable
    class Entry<out Key,out Item>(key, item)
            extends Object()
            given Key satisfies Object {

        "The key used to access the entry."
        shared Key key;

        "The item associated with the key."
        shared Item item;

        "A pair (2 element tuple) with the key and item of this
         entry. For any `entry`:

             entry.pair == [entry.key,entry.item]"
        shared [Key, Item] pair => [key, item];

        "An `Entry` with the key and item of this entry if this
         entry's item is non-null, or `null` otherwise."
        shared <Key->Item&Object>? coalesced
                => if (exists item) then key->item else null;

        "Determines if this entry is equal to the given entry.
         Two entries are equal if they have the same key and
         the same item.

         - The keys are considered the same if they are equal,
           in the sense of [[value equality|Object.equals]].
         - Two items are considered the same if they are both
           null or if neither is null and they are equal."
        shared actual Boolean equals(Object that) {
            if (is Entry<Object,Anything> that) {
                if (this.key!=that.key) {
                    return false;
                }
                if (exists thisItem=this.item,
                    exists thatItem=that.item) {
                    return thisItem==thatItem;
                }
                else {
                    return !this.item exists &&
                            !that.item exists;
                }
            }
            else {
                return false;
            }
        }

        shared actual Integer hash
                => (31 + key.hash) * 31 + (item?.hash else 0);

        "A description of the entry in the form `key->item`. If
         [[item]] is `null`, its string representation is the
         string `\"<null>\"`."
        shared actual String string
                => "``key``->``stringify(item)``";
    }