Ramda ohne Generics mit Versprechen Ketten in Typescript

Question

Ich habe ein wenig Schwierigkeiten, wie ramda mit seinem types mit Typescript verwenden, wo der Typescript-Compiler scheint nicht mit currying in Versprechen-Ketten zu stimmen. Hier ist ein kurzes Beispiel, das eine ausgehende API-Anfrage ausgibt, wobei makeRequest eine Hilfsfunktion ist, um die ausgehende Anfrage zu machen und den Hauptteil zurückzugeben.

import * as R from 'ramda'; 

interface Item { 
    [k: string]: string; 
} 

interface OtherResponse { 
    key: string; 
    value: string; 
} 

type ItemResponse = Item[] | Item[][] | OtherResponse; 

function makeRequest(): Promise<ItemResponse> { 
    // In the real world, this would make an outbound request, and return one of the 3 responses depending on parameters to makeRequest. 
    return Promise.resolve([[{foo: 'bar'}]]); 
} 

function getNestedItems(): Promise<Item[]> { 
    return (makeRequest() as Promise<Item[][]>) 
    .then(R.flatten); 
} 

getNestedItems() 
    .then(console.log) 
    .catch(console.error); 

Jetzt nur noch auf diesem Teil konzentrieren:

function getNestedItems(): Promise<Item[]> { 
    return (makeRequest() as Promise<Item[][]>) 
    .then(R.flatten); 
} 

Derzeit wird diese mir folgende Fehler gibt (Versuch 1):

TS2322: Type 'Promise<(Item | Item[])[]>' is not assignable to type 'Promise<Item[]>'. Type '(Item | Item[])[]' is not assignable to type 'Item[]'. Type 'Item | Item[]' is not assignable to type 'Item'. Type 'Item[]' is not assignable to type 'Item'. Index signature is missing in type 'Item[]'. 

Das ärgerlich, aber ich irgendwie verstehen, warum es ist nicht erlaubt, also Versuch 2:

function getNestedItems(): Promise<Item[]> { 
    return (makeRequest() as Promise<Item[][]>) 
    .then(data => R.flatten(data)); 
} 

Außer ich habe folgendes:

TS2322: Type 'Promise<Item[][]>' is not assignable to type 'Promise<Item[]>'. Type 'Item[][]' is not assignable to type 'Item[]'. Type 'Item[]' is not assignable to type 'Item'. Index signature is missing in type 'Item[]'. 

Nun ist dies nur falsch, das Typoskript Compiler ignoriert die Tatsache, dass R.flatten verwendet wird. Ich konnte nicht herausfinden, warum das passiert. Mein letzter Versuch war:

function getNestedItems(): Promise<Item[]> { 
    return (makeRequest() as Promise<Item[][]>) 
    .then(data => R.flatten<Item>(data)); 
} 

Während das funktioniert für mich nur hässlich ist, und entfernt viele der Vorteile, die aus Ramda des currying kommen.

Gibt es einen Standard/bevorzugten Weg, Ramda mit Promise-Ketten in Typescript zu verwenden, die nicht erfordert, dass ich jedes Mal Generics verwende, wenn ich eine Ramda-Funktion verwenden möchte?

EDIT:

tsconfig.json wenn interessiert:

{ 
    "compilerOptions": { 
    "module": "commonjs", 
    "moduleResolution": "node", 
    "noEmitOnError": true, 
    "noImplicitAny": true, 
    "noImplicitReturns": true, 
    "noImplicitThis": true, 
    "noUnusedLocals": true, 
    "noUnusedParameters": false, 
    "outDir": "dist", 
    "preserveConstEnums": true, 
    "removeComments": true, 
    "rootDir": ".", 
    "sourceMap": false, 
    "strictNullChecks": true, 
    "target": "es2015" 
    }, 
    "exclude": [ 
    "node_modules" 
    ], 
    "include": [ 
    "src/**/*.ts*", 
    "test/**/*.ts*" 
    ] 
} 

Answer 1

Sie die Ramda Typisierungen von hier https://github.com/DefinitelyTyped/DefinitelyTyped bekommen

in einem Projekt hinzuzufügen: Run: npm --save installieren -dev @ types/ramda

Hoffe es hilft!