struct Map<T> {
    
    Vec<Str>: keys
    Vec<T>: values

impl:
    inline fn Map.new<T>() -> [Map<T>] {
        Vec.new::<Str>
        Vec.new::<T>
        cast(Map)
    }

    inline fn Map.contains<T>(Str &Map<T>) -> [bool] {
        Map.get as [opt]
        &opt Option.is_some 
    }

    fn Map.insert<T>(Str: key T: value *Map<T>: self) -> [Option<T>] {

        key self Map.get_mut as [maybe_val]
        &maybe_val Option.is_some if {
            maybe_val Option.unwrap as [val]
            val @ Option.Some
            value val !
        } else {

            key   self::keys   Vec.push
            value self::values Vec.push
            Option.None::<T>
        }
    }

    fn Map.get_mut<T>(Str: key *Map<T>: self) -> [Option<*T>] {
        0 while dup self::keys Vec.len < do {
            as [i]

            key i self::keys Vec.at Option.unwrap Str.equals if {
                i self::values Vec.get_mut return 
            }

            i 1 + 
        } drop

        Option.None::<*T>
    }

    fn Map.get<T>(Str: key &Map<T>: self) -> [Option<&T>] {
        0 while dup self::keys Vec.len < do {
            as [i]
            key i self::keys Vec.at Option.unwrap Str.equals if {
                i self::values Vec.get return 
            }

            i 1 + 
        } drop

        Option.None::<&T>
    }

}