javascript - Typescript-Definition für Union-Typ js

Möchte Hilfe beim Schreiben einer d.ts-Datei für https://github.com/paldepind/union-type suchen

Mit dem untenstehenden Unionstyp,

let Maybe = Type({
    Nothing: []
    , Just: [Number]
})

Ich würde gerne einen Compilerfehler sehen, falls Maybe.Nothing() als Maybe.None() falsch geschrieben wird

Ich habe versucht, die Schlüssel aus dem Objektliteral zu erfassen, aber der Compiler erkennt Nothing und Just im resultierenden Typ Maybe immer noch nicht.

interface Obj {
    prototype: any
    case: (x: {[index: string]: (...args) => any}) => any
    caseOn: (x: {[index: string]: (...args) => any}) => any
}
interface Union<T> {
    (desc: T): T & Obj
}
var Type: Union<{[key: string]: any}>
export = Type

Antwort #1

Ich denke, wonach du suchst, sind Index-Typen, siehe den Abschnitt Erweiterte Typen im Handbuch für weitere Erklärungen, wie sie funktionieren. Ich habe auch eine Deklarationsdatei für paldepind/union-type erstellt, aber sie ist unvollständig :

declare module 'union-type' {
  type Constructors =
    | StringConstructor
    | NumberConstructor
    | ArrayConstructor
    | BooleanConstructor
    | ObjectConstructor
    | FunctionConstructor

  export default function Type<
    T extends {
      [k: string]: (Constructors | ((arg?: any) => boolean | Constructors))[]
    },
    K extends keyof T
  >(
    desc: T
  ): {
    // case(cases: { [k in K]: (...args: any[]) => void }, obj: any): void
    [k in K]: (...args: any[]) => any
  }
}

Ich versuche auch, eine Lösung für diese Bibliothek in TS zu finden...

Antwort #2

Wenn Sie nach einer Maybe-Implementierung suchen, hier ist eine, die ich einst geschrieben habe

/**
 * A Maybe implementation
 * that is JavaScript first
 * i.e. simple typed abstraction over null/undefined
 */
export class Maybe<T>{
    private _value: T;
    /** Based on value it will be Some or None */
    constructor(value: T) {
        this._value = value;
    }
    /** Shorthand for constructor */
    static Some<T>(value: T): Maybe<T> {
        if (value === null || value === undefined) {
            throw new Error('value for some cannot be null or undefied');
        }
        return new Maybe(value);
    };
    static None<T>(): Maybe<T> {
        return new Maybe(null);
    };
    get value(): T {
        return this._value;
    }
    get isSome() {
        return this._value !== null && this._value !== undefined;
    }
    get isNone() {
        return !this.isSome;
    }
    map<U>(mapper: (now: T) => U): Maybe<U> {
        if (this.isSome) {
            return new Maybe(mapper(this._value));
        }
        else {
            return new Maybe(null);
        }
    }
}

Das gesagt, finde ich es ziemlich nutzlos, es ist viel einfacher, sich einfach null/undefined bewusst zu sein und die valid-Eigenschaft an deinen Objekten zu verwenden (mehr https://medium.com/@basarat/null-vs-undefined-in-typescript-land-dc0c7a5f240a)

Mehr

Damit gesagt, wird TypeScript eine erstklassige Nullbarkeit-Unterstützung bekommen https://github.com/Microsoft/TypeScript/pull/7140 und Sie werden in der Lage sein, number | null | undefined zu verwenden, und es wird Ihnen nicht erlaubt sein, null einer Zahl zuzuweisen, d.h. let foo:number=null;/Fehler, foo ist nicht nullfähig