Les définitions de type récursives ne semblent pas fonctionner avec les génériques?

Question

Je pense que c'est un bug dans Typescript et je l'ai classé comme un problème here. Je ne m'y attendais pas à fixer (au moins pas de sitôt, alors je veux vous demander les gars, quelqu'un arrive d'avoir une idée pour une meilleure solution/travail autour de create_1?

code

type RecursivePartial<T> = { 
    [P in keyof T]?: RecursivePartial<T[P]>; 
}; 

type State<T> = { value: T }; 

function create_1<T>(){ 

    let _x: RecursivePartial<State<T>>; 
    let _y: State<RecursivePartial<T>>; 

    _x = _y; 
} 

function create_2<T>(){ 
/* 

*/ 

    let x: RecursivePartial<State<T>>; 
    let y: State<T>; 

    /* 
     Type 'State<T>' is not assignable to type RecursivePartial<State<T>>'. 
      Types of property 'value' are incompatible. 
       Type 'T' is not assignable to type RecursivePartial<T>[P]>'. 
        Type 'T[string]' is not assignable to type 'RecursivePartial<T[P]>'. 
    */ 

    x = y; 
} 

comportement attendu:. je ne m'y attendais le second exemple être dactylographiée valide, à savoir l'Etat devrait être cessible à RecursivePartial> Cela devrait être le cas que tout Etat serait une partie de celui-ci l'auto donné T est le même type

Comportement réel: Je reçois une erreur de type (voir ci-dessus), il semble que la définition de type récursive se brise quand elle rencontre un générique?

TS Playground link Le code et l'erreur de type peuvent être confirmés ici; ts-playground example

Answer 1

Cela ressemble à un bug pour moi. : Contournements

Comme je l'ai remarqué dans the Github issue, la première et la meilleure solution est probablement pour activer le strictNullCheckscompiler option. Je recommande vraiment de l'allumer et de le garder en général, car c'est très utile.

---

Si vous ne voulez pas faire cela, vous pouvez toujours utiliser un type assertion pour dire au compilateur que vous connaissez le type mieux que cela fait. Si le compilateur est vraiment résistant à faire une affirmation, vous pouvez passer à travers une affirmation de any, comme ceci:

function create_2<T>(){ 
    let x: RecursivePartial<State<T>>; 
    let y: State<T>; 
    x = y as any as RecursivePartial<State<T>>; // I know it! 
} 

---

Si vous ne voulez pas faire cela, vous pouvez changer la définition de RecursivePartial<> à ce qui suit:

type RecursivePartial<T> = { 
    [P in keyof T]?: T[P] | RecursivePartial<T[P]>; 
}; 

Ceci est, je crois, en fait la même chose, mais le compilateur a un temps plus facile de voir que vous pouvez toujours attribuer une valeur de type T à une variable de type RecursivePartial<T>.

---

Espérons que ça aide. Bonne chance!