HashedMap.ts

type Hash = string | number | symbol | object;

interface Hashable<K extends Hash> {
    readonly hash: K;
}

class FooId implements Hashable<number> {
    readonly primitive: number;

    constructor(primitive: number) {
        this.primitive = primitive;
    }

    get hash(): number {
        return this.primitive;
    }
}

class HashedMap<T extends Hashable<K>, V, K extends Hash = T extends Hashable<infer U> ? U : never> {
    private readonly map: Map<K, V>;

    constructor(source?: HashedMap<T, V, K>) {
        this.map = new Map(source?.map);
    }

    get({ hash }: T): V | undefined {
        return this.map.get(hash)
    }

    set({ hash }: T, value: V): void {
        this.map.set(hash, value);
    }
}

const map = new HashedMap<FooId, unknown>;

map.set(new FooId(1), "one");

const value = map.get(new FooId(1));