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
|
