Restricciones aritméticas de miembros hash en Typescript

¿Puedo definir de alguna manera un tipo en TypeScript que también aplique restricciones aritméticas a las propiedades de un objeto, por ejemplo?

type RestrictedObject = {
a: number,
b: number,
}

para que a % b=0

Respuesta #1

No, eso requeriría comprobación en tiempo de ejecución, lo cual está fuera del alcance de TypeScript.

Puedes definir un objeto con propiedades de acceso para hacer cumplir la relación:

class Restricted {
    #a: number;
    #b: number;

    static #valid(a: number, b: number): boolean {
        return a % b === 0;
    }

    constructor(a: number,  b:number) {
        if (Restricted.#valid(a, b)) {
            throw new Error(`The values of 'a' and 'b' must be such that 'a % b' is 0; ${a} and ${b} don't fit`);
        }
        this.#a = a;
        this.#b = b;
    }

    get a() {
        return this.#a;
    }
    set a(value) {
        if (this.#b !== null) {
            if (Restricted.#valid(value, this.#b)) {
                throw new Error(`The value of 'a' cannot be ${value} when 'b' is ${this.#b}`);
            }
        }
        this.#a = value;
    }

    get b() {
        return this.#b;
    }
    set b(value) {
        if (this.#a !== null) {
            if (Restricted.#valid(this.#a, value)) {
                throw new Error(`The value of 'b' cannot be ${value} when 'a' is ${this.#a}`);
            }
        }
        this.#b = value;
    }
}

Nota al margen: Lo anterior utiliza campos privados nativos y métodos estáticos privados de JavaScript, que ahora son partes especificadas del lenguaje, pero podrías usar private de TypeScript en su lugar si quisieras.