Ability to replace return type of function type #39594

Activity

1. Ryan Cavanaugh (RyanCavanaugh)

   added

   Awaiting More FeedbackThis means we'd like to hear from more people who would be helped by this featureThis means we'd like to hear from more people who would be helped by this feature

   SuggestionAn idea for TypeScriptAn idea for TypeScript

   on Jul 15, 2020
2. awerlogus commented on Aug 17, 2020

   

   Michael Borislav (awerlogus)

   on Aug 17, 2020

   More actions

   Very useful feature. This is the only way to implement flow function with unlimited parameters count, for example. We just need to recursively compute return type of the functions chain passed (this can be done using #38182) and then replace return type of the first function with it. There're very much cases of functions wrapping other functions and changing its return types. Ryan Cavanaugh (@RyanCavanaugh), You really should pay attention to this proposal.
3. TylorS commented on Aug 22, 2020

   

   Tylor Steinberger (TylorS)

   on Aug 22, 2020

   More actions

   This would indeed be a very useful feature! I think it might be incredibly useful to have a syntax for mapping over the entirety of a function type including type parameters and return type, similar to a mapping over object/tuple types. Does that sound useful to others in the thread?
4. awerlogus commented on Aug 22, 2020

   

   Michael Borislav (awerlogus)

   on Aug 22, 2020

   More actions

   Tylor Steinberger (@TylorS) We need to look at the code examples
5. saltman424 commented on Nov 15, 2024

   

   Sander Altman (saltman424)

   on Nov 15, 2024

   Last edited by saltman424

   More actions

   Just to add some life to this four-year-old issue. I have a use case of factories of factories. For example:

   Playground

   interface CacheEntry<T> {
     value: T
     cachedAt: Date
   }
   
   // This is where I want to swap the return type
   export function createCachedFactory<TFn extends (...args: any) => any>(factory: TFn) {
     const cache: Record<string, CacheEntry<ReturnType<TFn>>> = {}
     return (...args: Parameters<TFn>) => {
       const cacheKey = JSON.stringify(args)
       return cache[cacheKey] ??= { value: factory(...args), cachedAt: new Date() }
     }
   }
   
   interface Foo1 { bar1: number }
   export const makeFoo1 = createCachedFactory((bar1: number): Foo1 => ({ bar1 }))
   
   interface Foo2<T> { bar2: T }
   // This should be typed as: <T>(bar2: T) => CacheEntry<Foo2<T>>
   export const makeFoo2 = createCachedFactory(<T>(bar2: T): Foo2<T> => ({ bar2 }))

   Here are some proposed solutions (in order of desirability, with most desirable at the top):

   // Proposal 1: TypeScript intelligently determines that the inferred parameters
   // are used in the new parameters and the inferred return type is used in the
   // new return type, so the new function type should be generic, if the original
   // function type is generic
   declare function createCachedFactory<TFn extends (...args: any) => any>(factory: TFn):
     TFn extends (...args: infer TParams) => infer TRet 
       ? (...args: TParams) => CacheEntry<TRet>
       : (...args: Parameters<TFn>) => CacheEntry<ReturnType<TFn>>
   
   // Proposal 2: similar to proposal 1, but TypeScript is using the utility types
   // Parameters and ReturnType instead of directly inferred types
   declare function createCachedFactory<TFn extends (...args: any) => any>(factory: TFn):
     (...args: Parameters<TFn>) => CacheEntry<ReturnType<TFn>>
   
   // Proposal 3: a special type is used to add handling of generic functions. I am
   // not sure if this is really much easier to implement than proposal 1 or 2 as
   // there still needs to be some guardrails to handle misusing or not
   // inferring/using TParams and TRet
   declare function createCachedFactory<TFn extends (...args: any) => any>(factory: TFn):
     TFn extends GenericFunction<infer TParams, infer TRet>
       ? (...args: TParams) => CacheEntry<TRet>
       : (...args: Parameters<TFn>) => CacheEntry<ReturnType<TFn>>
   
   // Proposal 4: similar to proposal 3, but with additional special types for the
   // parameters and return types
   declare function createCachedFactory<TFn extends (...args: any) => any>(factory: TFn):
     TFn extends GenericFunction
       ? (...args: GenericParameters<TFn>) => CacheEntry<GenericReturnType<TFn>>
       : (...args: Parameters<TFn>) => CacheEntry<ReturnType<TFn>>
6. linonetwo commented on Nov 15, 2024

   

   lin onetwo (linonetwo)

   on Nov 15, 2024

   More actions

   Another related repo https://www.typescriptlang.org/play?jsx=1&ts=4.1.3#code/PTAEElQFwCwSwHYGtSIGYFMBOoBKGoBXLBANQEMAbQjUAIyw3JVlvIGMirRGiToAngAdaAezSgm7GKAAKAKHlRhtAIIBnAQnZw0A2VlEAPAQFYAPAHkscAOaIqB4wIB8oALygA3vNCgA2rKoCKBIGALioNZ2DpROJgC6AFxRNvYIjoYmgQmSRlAYCAAm6qAAFAB0VeRYtoQAtoVQ6gD6KeQIAgCUHm7o2HgExGRUNL5+oAD85VUVNXWNCM1tcjXkjQVY6lZpsfECOS497m5O9XDqGOb4fCPUGC7jfimEyAiiAO4IANzyAL6-eTAABUwN8wNAACFCLZUKUYNgMElwcBFOxRAh1FBQLZcR5yl4-qByKUNFodHp9hZwABhDEFfIAZWwADc4OwHl0KrYCGUAOSFNmGBCLKCkbDqOAY9R8rqAxQgsGgCGQjCUT7ExiCESgNCiHC0+kYJms9kYFHyY1CfXYxCbNAcWjgWTkWClHx+XAAUVUNIAKi1ZKo-QAJFJYmwIWy-Py0ywAOUDwbDoAjiGj-yBoPBoFULPIcEo5DolFo+fupWLokI2KwrwQ6ckCCFGNFFqtNuC9sdEDpmKgHWa3nGFwAIhgWWrREJRSk6KJRKWOjHQEIi1A9Vh6uGoJGM35BXBhaLxVspZiUl5iSkAMwAGnoKQALKAAZnLUZrVhbUtsA6Ob2Rr5HkBTFKUzqujA6gPoa-aDu6fwKtmyqgAAsh05A8qA6JwUsoDljQoCUHAYSgAABmOE5TjOTRkcSxSgPUHQCJIlCXA+6iiKAESENhHShO8HzEvONbCdWtb1o2h7Hk0wSMQWIQdEUPCFEUiI4EIhgcuopRMJKlACBU7afp2dp-j2sEMlAzJYGyAEejiBDmAA0iBqmlGEEQSJZxpQC4ZSeSkzldCkPn5P4zkJL8fxAA