Extended Map & Set

map-set-extended.ts

class ExtendedMap<K, V> extends Map<K, V> {
    update(key: K, updater: (value: V, key: K) => V, reset: V = undefined) {
        if (this.has(key)) {
            this.set(key, updater(this.get(key), key));
        }
        else this.set(key, reset);
    }

    filter(predicate: (value: V, key: K) => boolean) {
        const newMap = new ExtendedMap<K, V>();
        const entries = [...this.entries()]
        for (const [key, value] of entries) {
            if (predicate(value, key)) newMap.set(key, value);
        }
        return newMap
    }

    merge(map: Map<K, V>, resolver: (key: K, currentValue: V, outsideValue: V) => V = (k, v, outsideValue) => outsideValue) {
        const entries = [...map.entries()];
        for (const [key, value] of entries) {
            if (this.has(key)) {
                this.set(key, resolver(key, this.get(key), value));
            }
            else this.set(key, value)
        }
    }
}

class ExtendedSet<V> extends Set<V> {
    filter(predicate: (value: V) => boolean) {
        const newSet = new ExtendedSet<V>();
        const entries = [...this.entries()];
        for (const [value] of entries) {
            if (predicate(value)) {
                newSet.add(value);
            }
        }

        return newSet;
    }

    merge(set: Set<V>) {
        const entries = [...set.entries()];
        for (const kv of entries) {
            this.add(kv[0]);
        }
    }

    except(set: Set<V>) {
        const newSet = new ExtendedSet<V>();
        const entries = [...set.entries()];

        for (const [value] of entries) {
            if (!this.has(value)) {
                newSet.add(value)
            }
        }

        return newSet;
    }
}