=== tests/cases/compiler/typeInferenceReturnTypeCallback.ts ===
interface IList {
>IList : IList
>A : A
map(f: (t: A) => B): IList;
>map : (f: (t: A) => B) => IList
>B : B
>f : (t: A) => B
>t : A
>A : A
>B : B
>IList : IList
>B : B
}
class Nil implements IList{
>Nil : Nil
>C : C
>IList : IList
>C : C
map(f: (t: C) => D): IList {
>map : (f: (t: C) => D) => IList
>D : D
>f : (t: C) => D
>t : C
>C : C
>D : D
>IList : IList
>D : D
return null;
>null : null
}
}
class Cons implements IList{
>Cons : Cons
>T : T
>IList : IList
>T : T
map(f: (t: T) => U): IList {
>map : (f: (t: T) => U) => IList
>U : U
>f : (t: T) => U
>t : T
>T : T
>U : U
>IList : IList
>U : U
return this.foldRight(new Nil(), (t, acc) => {
>this.foldRight(new Nil(), (t, acc) => { return new Cons(); }) : Nil
>this.foldRight : (z: E, f: (t: T, acc: E) => E) => E
>this : Cons
>foldRight : (z: E, f: (t: T, acc: E) => E) => E
>new Nil() : Nil
>Nil : typeof Nil
>U : U
>(t, acc) => { return new Cons(); } : (t: T, acc: Nil) => Cons
>t : T
>acc : Nil
return new Cons();
>new Cons() : Cons
>Cons : typeof Cons
>U : U
});
}
foldRight(z: E, f: (t: T, acc: E) => E): E {
>foldRight : (z: E, f: (t: T, acc: E) => E) => E
>E : E
>z : E
>E : E
>f : (t: T, acc: E) => E
>t : T
>T : T
>acc : E
>E : E
>E : E
>E : E
return null;
>null : null
}
}