Maplike and Setlike objects that are fast and structurally compatible

map-set-like.mts

interface Maplike<key, value> {
    get(key: key): [value] | undefined;
    set(key: key, value?: value): void;
    delete(key: key): boolean;
}

interface Setlike<value>  {
    get(value: value): [unknown] | undefined;
    set(value: value): void;
    delete(value: value): boolean;
}

const Maplike: new <key, value>(placeholder: value) => Maplike<key, value> = class Bettermap<key, value> extends Map<key, value> {
    constructor(readonly placeholder: value) {
        super();
    }

    // @ts-expect-error
    get(key: key): [value] | undefined {
        if(!Map.prototype.has.call(this, key)) return undefined;
        return [Map.prototype.get.call(this, key)!];
    }

    // @ts-expect-error
    set(key: key, value: value = this.placeholder) {
        Map.prototype.set.call(this, key, value);
    }
}
Object.setPrototypeOf(Maplike.prototype, Object.prototype);
Object.defineProperty(Maplike.prototype, "delete", Object.getOwnPropertyDescriptor(Map.prototype, "delete")!);


const Setlike: new <value>() => Setlike<value> = class Betterset<value> extends Set<value> {
    get(value: value): [unknown] | undefined {
        if(!Set.prototype.has.call(this, value)) return undefined;
        return [value];
    }
    set(value: value) {
        Set.prototype.add.call(this, value);
    }
}
Object.setPrototypeOf(Setlike.prototype, Object.prototype);
Object.defineProperty(Setlike.prototype, "delete", Object.getOwnPropertyDescriptor(Set.prototype, "delete")!);

type Assert = (expr: unknown, message?: string) => asserts expr;
function createAssert(context: string): Assert {
    return (expr, message) => {
        if(!expr) throw new Error(`${context}: ${message}`);
    }
}

namespace testMaplike {
    const assert: Assert = createAssert("Maplike");

    const map = new Maplike<string, {}>({});
    assert(map.get("") === undefined, "Empty does not produce undefined");
    assert(map.set("", String) === undefined, "Set does not produce undefined");
    assert(map.delete("") === true, "Delete existing returns false");

    assert(map.get("") === undefined, "Deleted does not produce undefined");
    assert(map.set("", String) === undefined, "Set does not produce undefined");
    assert(map.get("") instanceof Array, "Get existing does not produce array");
    assert(map.get("")![0] === String, "Get keepExistingData does not produce correct value");
}

namespace testSetlike {
    const assert: Assert = createAssert("Setlike");

    const set = new Setlike<string>();
    assert(set.get("") === undefined, "Empty does not produce undefined");
    assert(set.set("") === undefined, "Set does not produce undefined");
    assert(set.delete("") === true, "Delete existing returns false");

    assert(set.get("") === undefined, "Deleted does not produce undefined");
    assert(set.set("") === undefined, "Set does not produce undefined");
    assert(set.get("") instanceof Array, "Get existing does not produce array");
    assert(set.get("")![0] !== undefined, "Get existing does not produce correct value");
}

namespace testSetlikeAsMaplike {
    const assert: Assert = createAssert("Setlike as Maplike");

    const map: Maplike<string, unknown> = new Setlike<string>();
    assert(map.get("") === undefined, "Empty does not produce undefined");
    assert(map.set("", String) === undefined, "Set does not produce undefined");
    assert(map.delete("") === true, "Delete existing returns false");

    assert(map.get("") === undefined, "Deleted does not produce undefined");
    assert(map.set("", String) === undefined, "Set does not produce undefined");
    assert(map.get("") instanceof Array, "Get existing does not produce array");
    assert(map.get("")![0] !== undefined, "Get existing does not produce correct value");
}

namespace testSetlike {
    const assert: Assert = createAssert("Maplike as Setlike");

    const set: Setlike<string> = new Maplike<string, {}>({});
    assert(set.get("") === undefined, "Empty does not produce undefined");
    assert(set.set("") === undefined, "Set does not produce undefined");
    assert(set.delete("") === true, "Delete existing returns false");

    assert(set.get("") === undefined, "Deleted does not produce undefined");
    assert(set.set("") === undefined, "Set does not produce undefined");
    assert(set.get("") instanceof Array, "Get existing does not produce array");
    assert(set.get("")![0] !== undefined, "Get existing does not produce correct value");
}