在TypeScript中，是否有任何方法可以将函数返回值键入函数本身？

Question

For the last week, I've been researching how it could be possible to type function return values to the funtion itself in TypeScript.

What is hard to me is types are not the first-class object in TypeScript(or any other type systems, not sure).

In a sense, I'm seeking a way for Self-reference types; not only identifies itself but also distinguishes from any others.

In fact, I've implemented such a thing in vanilaJS.

example1: Member type to a return value of a function: Member

log("=Are you a member? ========= ");
const Member = a => Type(Member)([a]); // Member = a=>[a]

const alice = ["Alice"];
const bob = Member("Bob"); //["Bob"]

log(
    isType(Member)(alice)
);//false
log(
    isType(Member)(bob)
);//true

example2: specialOperation type to a certain functions

log("=Is this a special operation? ========= ");
const specialOperation = f => Type(specialOperation)(f);

const f1 = a => a + 1; //vanilla function
const f2 = Type(specialOperation) //typed function
    (a => {
        //This function might be considered to be "special" 
        //because it does some featured operations in a context.
        return a * 2;
    });

log(
    isType(specialOperation)(f1)
);//false
log(
    isType(specialOperation)(f2)
);//true
log(
    f2(1) // f2 = a => a * 2
);//2  // just in case, let you know

exapmples and test

 //--- debug use const log = (m) => { console.log(m); //IO return m; }; //---- a type sysetm in vanillaJS const typedPrimitive = T => i => { const derived = Object(i); Object.setPrototypeOf(derived, Object(i)); const typeProperty = { enumerable: false, configurable: false, writable: false, value: true }; Object.defineProperty(derived, T, typeProperty); return derived; }; const typedObject = T => i => { const handler = { get: (target, name) => name == T//must == ? true : target[name] }; return new Proxy(i, handler); }; const typed = T => i => (i !== Object(i))//primitives ? typedPrimitive(T)(i) : typedObject(T)(i) const istype = T => i => i[T] === true; const Type = T => i => (i === T) || (i == null) ? i : typed(T)(i); const isType = T => i => (i === T) ? true : (i == null) ? false : istype(T)(i); //------------------------------------------ log("=Are you a member? ========= "); const Member = a => Type(Member)([a]); // M = a=>[a] const alice = ["Alice"]; const bob = Member("Bob"); //["Bob"] log( isType(Member)(alice) );//false log( isType(Member)(bob) );//true log("=Is this a special operation? ========= "); const specialOperation = f => Type(specialOperation)(f); const f1 = a => a + 1; //vanilla function const f2 = Type(specialOperation) //typed function (a => { //This function might be considered to be "special" //because it does some featured operations in a context. return a * 2; }); log( isType(specialOperation)(f1) );//false log( isType(specialOperation)(f2) );//true log( f2(1) // f2 = a => a * 2 );//2 // just in case, let you know log("=type test of nontyped========================="); const I = a => a; //just a dummy function log( isType(I)(I) // true ); log( isType(I)(1) // false ); log( isType(I)([]) // fakse ); log( isType(I)({}) // false ); log( isType(I)("hello") //fakse ); log( isType(I)(x => x) // false ); log( isType(I)(true) // false ); log( isType(I)(false) // false ); log("=type test of typed========================="); log( isType(I)(Type(I)(I)) // true ); log( isType(I)(Type(I)(1)) // true ); log( isType(I)(Type(I)([])) // true ); log( isType(I)(Type(I)({})) // true ); log( isType(I)(Type(I)("hello")) //true ); log( isType(I)(Type(I)(x => x)) // true ); log( isType(I)(Type(I)(true)) // true ); log( isType(I)(Type(I)(false)) // true ); log( (Type(I)(false) == false) ? "Type(I)(false) == false (as should be)" : "something is wrong" ); log( (Type(I)(false) !== false)//Object !== Primitive ? "Type(I)(false) !== false (as should be)" : "something is wrong" ); log( isType(I)(Type(I)(NaN)) //true ); log( isType(I)(Type(I)(undefined)) // false ); log( isType(I)(Type(I)(null)) // false ); log( Type(I)(1) + Type(I)(2)//3 ); log( Type(I)([1, 2, 3]) );//[1, 2, 3] 

Although I think this method is quite useful in JavaScript, and the code runs also in TypeScript, I wonder if it's possible to implement in a sophisticated TypeScript way, because if there is better and "native manner" to do this in TypeScript, mixing another implementation by my own should be quite redundant.

Thank you.

Answer 1

This can be accomplished with conditional types introduced in typescript 2.8:

let someFunction: () => String;
let x : ReturnType<typeof someFunction>;

In case you are curious about the design alternatives the typescript team considered, the discussion in #6606 provides a good overview.