Mixing
Is there ArgumentsType like ReturnType in Typescript?
ReturnType<T> extracts return type of a function.
Is there a way to define ArgumentsType<T> that extracts parameter types of a function in tuple format?
For example,
ArgumentsType<(a: number, b: string) => boolean> will be [number, string].
typescript
asked Jul 12 '18 at 7:22
JoonJoon
3,82622752
add a comment |
ReturnType<T> extracts return type of a function.
Is there a way to define ArgumentsType<T> that extracts parameter types of a function in tuple format?
For example,
ArgumentsType<(a: number, b: string) => boolean> will be [number, string].
typescript
asked Jul 12 '18 at 7:22
JoonJoon
3,82622752
add a comment |
ReturnType<T> extracts return type of a function.
Is there a way to define ArgumentsType<T> that extracts parameter types of a function in tuple format?
For example,
ArgumentsType<(a: number, b: string) => boolean> will be [number, string].
typescript
asked Jul 12 '18 at 7:22
JoonJoon
3,82622752
ReturnType<T> extracts return type of a function.
Is there a way to define ArgumentsType<T> that extracts parameter types of a function in tuple format?
For example,
ArgumentsType<(a: number, b: string) => boolean> will be [number, string].
typescript
typescript
asked Jul 12 '18 at 7:22
JoonJoon
3,82622752
asked Jul 12 '18 at 7:22
JoonJoon
3,82622752
asked Jul 12 '18 at 7:22
JoonJoon
3,82622752
asked Jul 12 '18 at 7:22
JoonJoon
3,82622752
asked Jul 12 '18 at 7:22
JoonJoon
3,82622752
3,82622752
add a comment |
add a comment |
3 Answers
3
active
oldest
votes
Edit
Since writing the original answer, typescript now has a built-in type (defined in lib.d.ts) to get the type of the parameters called Parameters
type argsEmpty = Parameters<() => void> //
type args = Parameters<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = Parameters<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
Edit Typescript 3.0 has been relesed the code below works as expected.
While this is not possible in the current version of typescript (2.9) without spelling out all parameters. It will become possible in the next version of typescript (3.0) which will be released in the next few days:
type ArgumentsType<T> = T extends (...args: infer U) => any ? U: never;
type argsEmpty = ArgumentsType<() => void> //
type args = ArgumentsType<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = ArgumentsType<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
If you install npm install typescript@next you can already play with this, it should be available sometime this month.
Note
We can also spread a tuple into arguments with this new feature:
type Spread<T extends any> = (...args: T)=> void;
type Func = Spread<args> //(x: number, y: string, z: boolean) => void
You can read more about this feature here
answered Jul 12 '18 at 7:48
Titian Cernicova-DragomirTitian Cernicova-Dragomir
69.3k34765
Looking forward to it! Thank you!
– Joon
Jul 12 '18 at 7:57
@Joon Yup me too, I'm going to have to rewrite a lot of answers, this features makes everything simpler :)
– Titian Cernicova-Dragomir
Jul 12 '18 at 8:03
add a comment |
As of TypeScript 3.1, Parameters type is now a part of the standard library.
type Result = Parameters<(a: number, b: string) => boolean>; // [number, string]
answered Dec 31 '18 at 1:28
Karol MajewskiKarol Majewski
4,021215
What version? Doesn't seem to be in 3.0.1
– blockhead
Jan 1 at 10:36
The pull request doesn't mention any milestone, but it is most definitely there in TypeScript 3.1.
– Karol Majewski
Jan 1 at 13:46
add a comment |
There is no way for now to extract both the types and amount of arguments for any function possible. But you can try something like this:
type ArgumentTypes<T> = T extends () => any ? never :
T extends (a1: infer T1) => any ? [T1] :
T extends (a1: infer T1, a2: infer T2) => any ? [T1, T2] :
// continue here for any reasonable number of args
never;
Check it with the following:
const args0: ArgumentTypes<() => boolean> = ; // correct
const args1: ArgumentTypes<(a: number) => boolean> = [1]; // correct
const args2: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str']; // correct
const oops0null: ArgumentTypes<() => boolean> = null; // error, arguments are array (but empty one)
const oops01: ArgumentTypes<() => boolean> = [1]; // error, arguments must be empty
const oops10: ArgumentTypes<(a: number) => boolean> = ; // error, we need one argument
const oops12: ArgumentTypes<(a: number) => boolean> = [1, 2]; // error, we need only one argument
const oops1wrong: ArgumentTypes<(a: number) => boolean> = ['str']; // error, argument must be number
const oops21: ArgumentTypes<(a: number, b: string) => boolean> = [1]; // error, we need two arguments
const oops23: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str', undefined]; // error, we need only two arguments
const oops2wrong: ArgumentTypes<(a: number, b: string) => boolean> = ['str', 1]; // error, arguments are reversed
Note that this don't have any use of optional arguments - they are just omitted from the output. I wasn't able to find a way to catch them for now.
answered Jul 12 '18 at 7:45
CerberusCerberus
1,031819
This can be useful before 3.0. Thank you!
– Joon
Jul 12 '18 at 7:58
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f51299555%2fis-there-argumentstypet-like-returntypet-in-typescript%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
3 Answers
3
active
oldest
votes
3 Answers
3
active
oldest
votes
active
oldest
votes
active
oldest
votes
Edit
Since writing the original answer, typescript now has a built-in type (defined in lib.d.ts) to get the type of the parameters called Parameters
type argsEmpty = Parameters<() => void> //
type args = Parameters<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = Parameters<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
Edit Typescript 3.0 has been relesed the code below works as expected.
While this is not possible in the current version of typescript (2.9) without spelling out all parameters. It will become possible in the next version of typescript (3.0) which will be released in the next few days:
type ArgumentsType<T> = T extends (...args: infer U) => any ? U: never;
type argsEmpty = ArgumentsType<() => void> //
type args = ArgumentsType<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = ArgumentsType<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
If you install npm install typescript@next you can already play with this, it should be available sometime this month.
Note
We can also spread a tuple into arguments with this new feature:
type Spread<T extends any> = (...args: T)=> void;
type Func = Spread<args> //(x: number, y: string, z: boolean) => void
You can read more about this feature here
answered Jul 12 '18 at 7:48
Titian Cernicova-DragomirTitian Cernicova-Dragomir
69.3k34765
Looking forward to it! Thank you!
– Joon
Jul 12 '18 at 7:57
@Joon Yup me too, I'm going to have to rewrite a lot of answers, this features makes everything simpler :)
– Titian Cernicova-Dragomir
Jul 12 '18 at 8:03
add a comment |
Edit
Since writing the original answer, typescript now has a built-in type (defined in lib.d.ts) to get the type of the parameters called Parameters
type argsEmpty = Parameters<() => void> //
type args = Parameters<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = Parameters<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
Edit Typescript 3.0 has been relesed the code below works as expected.
While this is not possible in the current version of typescript (2.9) without spelling out all parameters. It will become possible in the next version of typescript (3.0) which will be released in the next few days:
type ArgumentsType<T> = T extends (...args: infer U) => any ? U: never;
type argsEmpty = ArgumentsType<() => void> //
type args = ArgumentsType<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = ArgumentsType<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
If you install npm install typescript@next you can already play with this, it should be available sometime this month.
Note
We can also spread a tuple into arguments with this new feature:
type Spread<T extends any> = (...args: T)=> void;
type Func = Spread<args> //(x: number, y: string, z: boolean) => void
You can read more about this feature here
answered Jul 12 '18 at 7:48
Titian Cernicova-DragomirTitian Cernicova-Dragomir
69.3k34765
Looking forward to it! Thank you!
– Joon
Jul 12 '18 at 7:57
@Joon Yup me too, I'm going to have to rewrite a lot of answers, this features makes everything simpler :)
– Titian Cernicova-Dragomir
Jul 12 '18 at 8:03
add a comment |
Edit
Since writing the original answer, typescript now has a built-in type (defined in lib.d.ts) to get the type of the parameters called Parameters
type argsEmpty = Parameters<() => void> //
type args = Parameters<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = Parameters<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
Edit Typescript 3.0 has been relesed the code below works as expected.
While this is not possible in the current version of typescript (2.9) without spelling out all parameters. It will become possible in the next version of typescript (3.0) which will be released in the next few days:
type ArgumentsType<T> = T extends (...args: infer U) => any ? U: never;
type argsEmpty = ArgumentsType<() => void> //
type args = ArgumentsType<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = ArgumentsType<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
If you install npm install typescript@next you can already play with this, it should be available sometime this month.
Note
We can also spread a tuple into arguments with this new feature:
type Spread<T extends any> = (...args: T)=> void;
type Func = Spread<args> //(x: number, y: string, z: boolean) => void
You can read more about this feature here
answered Jul 12 '18 at 7:48
Titian Cernicova-DragomirTitian Cernicova-Dragomir
69.3k34765
Edit
Since writing the original answer, typescript now has a built-in type (defined in lib.d.ts) to get the type of the parameters called Parameters
type argsEmpty = Parameters<() => void> //
type args = Parameters<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = Parameters<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
Edit Typescript 3.0 has been relesed the code below works as expected.
While this is not possible in the current version of typescript (2.9) without spelling out all parameters. It will become possible in the next version of typescript (3.0) which will be released in the next few days:
type ArgumentsType<T> = T extends (...args: infer U) => any ? U: never;
type argsEmpty = ArgumentsType<() => void> //
type args = ArgumentsType<(x: number, y: string, z: boolean) => void> // [number, string, boolean]
type argsOpt = ArgumentsType<(x: number, y?: string, z?: boolean) => void> // [number, (string | undefined)?, (boolean | undefined)?]
If you install npm install typescript@next you can already play with this, it should be available sometime this month.
Note
We can also spread a tuple into arguments with this new feature:
type Spread<T extends any> = (...args: T)=> void;
type Func = Spread<args> //(x: number, y: string, z: boolean) => void
You can read more about this feature here
answered Jul 12 '18 at 7:48
Titian Cernicova-DragomirTitian Cernicova-Dragomir
69.3k34765
edited Jan 11 at 9:04
answered Jul 12 '18 at 7:48
Titian Cernicova-DragomirTitian Cernicova-Dragomir
69.3k34765
answered Jul 12 '18 at 7:48
Titian Cernicova-DragomirTitian Cernicova-Dragomir
69.3k34765
answered Jul 12 '18 at 7:48
Titian Cernicova-DragomirTitian Cernicova-Dragomir
69.3k34765
69.3k34765
Looking forward to it! Thank you!
– Joon
Jul 12 '18 at 7:57
@Joon Yup me too, I'm going to have to rewrite a lot of answers, this features makes everything simpler :)
– Titian Cernicova-Dragomir
Jul 12 '18 at 8:03
add a comment |
Looking forward to it! Thank you!
– Joon
Jul 12 '18 at 7:57
@Joon Yup me too, I'm going to have to rewrite a lot of answers, this features makes everything simpler :)
– Titian Cernicova-Dragomir
Jul 12 '18 at 8:03
Looking forward to it! Thank you!
– Joon
Jul 12 '18 at 7:57
Looking forward to it! Thank you!
– Joon
Jul 12 '18 at 7:57
@Joon Yup me too, I'm going to have to rewrite a lot of answers, this features makes everything simpler :)
– Titian Cernicova-Dragomir
Jul 12 '18 at 8:03
@Joon Yup me too, I'm going to have to rewrite a lot of answers, this features makes everything simpler :)
– Titian Cernicova-Dragomir
Jul 12 '18 at 8:03
add a comment |
As of TypeScript 3.1, Parameters type is now a part of the standard library.
type Result = Parameters<(a: number, b: string) => boolean>; // [number, string]
answered Dec 31 '18 at 1:28
Karol MajewskiKarol Majewski
4,021215
What version? Doesn't seem to be in 3.0.1
– blockhead
Jan 1 at 10:36
The pull request doesn't mention any milestone, but it is most definitely there in TypeScript 3.1.
– Karol Majewski
Jan 1 at 13:46
add a comment |
As of TypeScript 3.1, Parameters type is now a part of the standard library.
type Result = Parameters<(a: number, b: string) => boolean>; // [number, string]
answered Dec 31 '18 at 1:28
Karol MajewskiKarol Majewski
4,021215
What version? Doesn't seem to be in 3.0.1
– blockhead
Jan 1 at 10:36
The pull request doesn't mention any milestone, but it is most definitely there in TypeScript 3.1.
– Karol Majewski
Jan 1 at 13:46
add a comment |
As of TypeScript 3.1, Parameters type is now a part of the standard library.
type Result = Parameters<(a: number, b: string) => boolean>; // [number, string]
answered Dec 31 '18 at 1:28
Karol MajewskiKarol Majewski
4,021215
As of TypeScript 3.1, Parameters type is now a part of the standard library.
type Result = Parameters<(a: number, b: string) => boolean>; // [number, string]
answered Dec 31 '18 at 1:28
Karol MajewskiKarol Majewski
4,021215
edited Jan 1 at 13:48
answered Dec 31 '18 at 1:28
Karol MajewskiKarol Majewski
4,021215
answered Dec 31 '18 at 1:28
Karol MajewskiKarol Majewski
4,021215
answered Dec 31 '18 at 1:28
Karol MajewskiKarol Majewski
4,021215
4,021215
What version? Doesn't seem to be in 3.0.1
– blockhead
Jan 1 at 10:36
The pull request doesn't mention any milestone, but it is most definitely there in TypeScript 3.1.
– Karol Majewski
Jan 1 at 13:46
add a comment |
What version? Doesn't seem to be in 3.0.1
– blockhead
Jan 1 at 10:36
The pull request doesn't mention any milestone, but it is most definitely there in TypeScript 3.1.
– Karol Majewski
Jan 1 at 13:46
What version? Doesn't seem to be in 3.0.1
– blockhead
Jan 1 at 10:36
What version? Doesn't seem to be in 3.0.1
– blockhead
Jan 1 at 10:36
The pull request doesn't mention any milestone, but it is most definitely there in TypeScript 3.1.
– Karol Majewski
Jan 1 at 13:46
The pull request doesn't mention any milestone, but it is most definitely there in TypeScript 3.1.
– Karol Majewski
Jan 1 at 13:46
add a comment |
There is no way for now to extract both the types and amount of arguments for any function possible. But you can try something like this:
type ArgumentTypes<T> = T extends () => any ? never :
T extends (a1: infer T1) => any ? [T1] :
T extends (a1: infer T1, a2: infer T2) => any ? [T1, T2] :
// continue here for any reasonable number of args
never;
Check it with the following:
const args0: ArgumentTypes<() => boolean> = ; // correct
const args1: ArgumentTypes<(a: number) => boolean> = [1]; // correct
const args2: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str']; // correct
const oops0null: ArgumentTypes<() => boolean> = null; // error, arguments are array (but empty one)
const oops01: ArgumentTypes<() => boolean> = [1]; // error, arguments must be empty
const oops10: ArgumentTypes<(a: number) => boolean> = ; // error, we need one argument
const oops12: ArgumentTypes<(a: number) => boolean> = [1, 2]; // error, we need only one argument
const oops1wrong: ArgumentTypes<(a: number) => boolean> = ['str']; // error, argument must be number
const oops21: ArgumentTypes<(a: number, b: string) => boolean> = [1]; // error, we need two arguments
const oops23: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str', undefined]; // error, we need only two arguments
const oops2wrong: ArgumentTypes<(a: number, b: string) => boolean> = ['str', 1]; // error, arguments are reversed
Note that this don't have any use of optional arguments - they are just omitted from the output. I wasn't able to find a way to catch them for now.
answered Jul 12 '18 at 7:45
CerberusCerberus
1,031819
This can be useful before 3.0. Thank you!
– Joon
Jul 12 '18 at 7:58
add a comment |
There is no way for now to extract both the types and amount of arguments for any function possible. But you can try something like this:
type ArgumentTypes<T> = T extends () => any ? never :
T extends (a1: infer T1) => any ? [T1] :
T extends (a1: infer T1, a2: infer T2) => any ? [T1, T2] :
// continue here for any reasonable number of args
never;
Check it with the following:
const args0: ArgumentTypes<() => boolean> = ; // correct
const args1: ArgumentTypes<(a: number) => boolean> = [1]; // correct
const args2: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str']; // correct
const oops0null: ArgumentTypes<() => boolean> = null; // error, arguments are array (but empty one)
const oops01: ArgumentTypes<() => boolean> = [1]; // error, arguments must be empty
const oops10: ArgumentTypes<(a: number) => boolean> = ; // error, we need one argument
const oops12: ArgumentTypes<(a: number) => boolean> = [1, 2]; // error, we need only one argument
const oops1wrong: ArgumentTypes<(a: number) => boolean> = ['str']; // error, argument must be number
const oops21: ArgumentTypes<(a: number, b: string) => boolean> = [1]; // error, we need two arguments
const oops23: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str', undefined]; // error, we need only two arguments
const oops2wrong: ArgumentTypes<(a: number, b: string) => boolean> = ['str', 1]; // error, arguments are reversed
Note that this don't have any use of optional arguments - they are just omitted from the output. I wasn't able to find a way to catch them for now.
answered Jul 12 '18 at 7:45
CerberusCerberus
1,031819
This can be useful before 3.0. Thank you!
– Joon
Jul 12 '18 at 7:58
add a comment |
There is no way for now to extract both the types and amount of arguments for any function possible. But you can try something like this:
type ArgumentTypes<T> = T extends () => any ? never :
T extends (a1: infer T1) => any ? [T1] :
T extends (a1: infer T1, a2: infer T2) => any ? [T1, T2] :
// continue here for any reasonable number of args
never;
Check it with the following:
const args0: ArgumentTypes<() => boolean> = ; // correct
const args1: ArgumentTypes<(a: number) => boolean> = [1]; // correct
const args2: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str']; // correct
const oops0null: ArgumentTypes<() => boolean> = null; // error, arguments are array (but empty one)
const oops01: ArgumentTypes<() => boolean> = [1]; // error, arguments must be empty
const oops10: ArgumentTypes<(a: number) => boolean> = ; // error, we need one argument
const oops12: ArgumentTypes<(a: number) => boolean> = [1, 2]; // error, we need only one argument
const oops1wrong: ArgumentTypes<(a: number) => boolean> = ['str']; // error, argument must be number
const oops21: ArgumentTypes<(a: number, b: string) => boolean> = [1]; // error, we need two arguments
const oops23: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str', undefined]; // error, we need only two arguments
const oops2wrong: ArgumentTypes<(a: number, b: string) => boolean> = ['str', 1]; // error, arguments are reversed
Note that this don't have any use of optional arguments - they are just omitted from the output. I wasn't able to find a way to catch them for now.
answered Jul 12 '18 at 7:45
CerberusCerberus
1,031819
There is no way for now to extract both the types and amount of arguments for any function possible. But you can try something like this:
type ArgumentTypes<T> = T extends () => any ? never :
T extends (a1: infer T1) => any ? [T1] :
T extends (a1: infer T1, a2: infer T2) => any ? [T1, T2] :
// continue here for any reasonable number of args
never;
Check it with the following:
const args0: ArgumentTypes<() => boolean> = ; // correct
const args1: ArgumentTypes<(a: number) => boolean> = [1]; // correct
const args2: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str']; // correct
const oops0null: ArgumentTypes<() => boolean> = null; // error, arguments are array (but empty one)
const oops01: ArgumentTypes<() => boolean> = [1]; // error, arguments must be empty
const oops10: ArgumentTypes<(a: number) => boolean> = ; // error, we need one argument
const oops12: ArgumentTypes<(a: number) => boolean> = [1, 2]; // error, we need only one argument
const oops1wrong: ArgumentTypes<(a: number) => boolean> = ['str']; // error, argument must be number
const oops21: ArgumentTypes<(a: number, b: string) => boolean> = [1]; // error, we need two arguments
const oops23: ArgumentTypes<(a: number, b: string) => boolean> = [1, 'str', undefined]; // error, we need only two arguments
const oops2wrong: ArgumentTypes<(a: number, b: string) => boolean> = ['str', 1]; // error, arguments are reversed
Note that this don't have any use of optional arguments - they are just omitted from the output. I wasn't able to find a way to catch them for now.
answered Jul 12 '18 at 7:45
CerberusCerberus
1,031819
answered Jul 12 '18 at 7:45
CerberusCerberus
1,031819
answered Jul 12 '18 at 7:45
CerberusCerberus
1,031819
answered Jul 12 '18 at 7:45
CerberusCerberus
1,031819
1,031819
This can be useful before 3.0. Thank you!
– Joon
Jul 12 '18 at 7:58
add a comment |
This can be useful before 3.0. Thank you!
– Joon
Jul 12 '18 at 7:58
This can be useful before 3.0. Thank you!
– Joon
Jul 12 '18 at 7:58
This can be useful before 3.0. Thank you!
– Joon
Jul 12 '18 at 7:58
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f51299555%2fis-there-argumentstypet-like-returntypet-in-typescript%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
