TypeScript/tests/baselines/reference/inferenceAndHKTs.types at 64a864b4d5a48e5a56e6a1199e687efaa13181c9 · microsoft/TypeScript · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
=== tests/cases/compiler/inferenceAndHKTs.ts ===
// Repro from #53970

export interface TypeLambda {
    readonly A: unknown;
>A : unknown
}

export interface TypeClass<F extends TypeLambda> {
    readonly _F: F;
>_F : F
}

export type Apply<F extends TypeLambda, A> = F extends { readonly type: unknown }
>Apply : Apply<F, A>
>type : unknown

    ? (F & { readonly A: A })['type']
>A : A

    : { readonly F: F, readonly A: A };
>F : F
>A : A

export interface T<A> {
    value: A;
>value : A
}

export interface TTypeLambda extends TypeLambda {
    readonly type: T<this["A"]>;
>type : T<this["A"]>
}

export declare const map: <F extends TypeLambda>(F: TypeClass<F>) => <A, B>(a: Apply<F, A>, f: (a: A) => B) => Apply<F, B>;
>map : <F extends TypeLambda>(F: TypeClass<F>) => <A, B>(a: Apply<F, A>, f: (a: A) => B) => Apply<F, B>
>F : TypeClass<F>
>a : Apply<F, A>
>f : (a: A) => B
>a : A

declare const typeClass: TypeClass<TTypeLambda>;
>typeClass : TypeClass<TTypeLambda>

declare const a: T<number>;
>a : T<number>

const x1 = map(typeClass);
>x1 : <A, B>(a: T<A>, f: (a: A) => B) => T<B>
>map(typeClass) : <A, B>(a: T<A>, f: (a: A) => B) => T<B>
>map : <F extends TypeLambda>(F: TypeClass<F>) => <A, B>(a: Apply<F, A>, f: (a: A) => B) => Apply<F, B>
>typeClass : TypeClass<TTypeLambda>

const x2 = map(typeClass)(a, (_) => _);  // T<number>
>x2 : T<number>
>map(typeClass)(a, (_) => _) : T<number>
>map(typeClass) : <A, B>(a: T<A>, f: (a: A) => B) => T<B>
>map : <F extends TypeLambda>(F: TypeClass<F>) => <A, B>(a: Apply<F, A>, f: (a: A) => B) => Apply<F, B>
>typeClass : TypeClass<TTypeLambda>
>a : T<number>
>(_) => _ : (_: number) => number
>_ : number
>_ : number