Unfortunately, TypeScript's type system does not currently support higher kinded types that are necessary to directly execute the operation you are attempting. Before TypeScript versions 3.4/3.5, your only option would have been to manually define the function typing you require:
function newExampleManual<T>(...args: [T]) {
return new Example(...args);
}
Luckily, TypeScript has made some progress in this area with version 3.4 which introduced support for higher order type inference from generic functions, and later version 3.5 brought support for generic constructors. This offers a way to achieve the desired function type, albeit not purely at the type level. The approach involves representing the transformation as the effect of a generic function that can accept other functions or constructors as callbacks.
For example:
const ctorToFn =
<A extends any[], R>(ctor: new (...args: A) => R) => (...args: A) => new ctor(...args);
const newExample = ctorToFn(Example);
// const newExample: <T>(value: T) => Example<T>
In this code snippet, ctorToFn() transforms any constructor into a function by using the passed arguments to invoke the construct signature of the constructor. Therefore, calling ctorToFn(Example) gives you the newExample implementation you desire along with the appropriate type signature:
<T>(value: T) => Example<T>
.
Subsequently, you can use it like this:
const exampleNumber = newExample(3);
// const exampleNumber: Example<number>
const exampleString = newExample('foo');
// const exampleString: Example<string>
Click here to view playground link with code.