With "pytorch does not support" I think you mean that TorchScript doesn't support it, right? It would be useful to document this List/Tuple/Sequence stuff (maybe on the wiki), because it will come back a lot.

• Here all these things actually are tuples (because they're coerced to that with _single, _double, etc.). and Tuple is supported by torchscript. But everything is still annotated as List[int], and the JIT seems happy with that. Unclear to me why it shouldn't be annotated as Tuple[int, ...] instead. I tried that on this PR, and it seems to not fail the tests in test/jit/test_models.py (however, it doesn't fail for Sequence[int] either, which was unexpected for me).
• Conv*D.__init__ uses _size_1_t etc. annotations, which are unions. The JIT seems happy with that as well, it's unclear to me why (Union is not supported).
• It'd be useful to add Sequence to https://pytorch.org/docs/master/jit_language_reference.html#unsupported-typing-constructs
• Can we rely on tests breaking if we change one of these annotations in a way that would break torchscript? I assume yes, but if not we need a test/check procedure (e.g. check if feature is in https://pytorch.org/docs/master/jit_builtin_functions.html#supported-pytorch-functions).

@suo, @ezyang could you comment on this?

I've added Sequence to the list of unsupported typing constructs

actually I am not sure if this is necessary --> I guess the reason why you want to use Sequence here is bc _output_padding returns a List[int] but others expect a Tuple[int, ...]. but in fact it is a helper function only for this module. we can change its return .

also if that's the case you can also change the argument types to Tuple[int, ...] as well. ??

Sorry for the late reply, but yes, problem with Tuple[int, ...] is that torch.jit.script can not parse that correctly.
I've tried to fix that in #44774 but it requires a bit more work.
_size_N_t is a special type which is defined as Union[int, Tuple[int * N]], which gets automagically promoted to list by torch.jit runtime.

Then change the final return to

-        return ret
+        return tuple(ret)

Thanks! I've updated the source code with the suggested changes

I'll revert the commit since one of the jit tests is failing with the message:

RuntimeError: 
Expression of type dots cannot be used in a type expression:
  File "/opt/conda/lib/python3.6/site-packages/torch/nn/modules/conv.py", line 536
    def _output_padding(self, input: Tensor, output_size: Optional[List[int]],
                        stride: Tuple[int, ...], padding: Tuple[int, ...], kernel_size: Tuple[int, ...],
                                           ~~~ <--- HERE
                        dilation: Optional[Tuple[int, ...]] = None) -> Tuple[int, ...]:
        if output_size is None:
'ConvTranspose1d._output_padding' is being compiled since it was called from 'ConvTranspose1d.forward'
  File "/opt/conda/lib/python3.6/site-packages/torch/nn/modules/conv.py", line 688
            raise ValueError('Only `zeros` padding mode is supported for ConvTranspose1d')
    
        output_padding = self._output_padding(
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            input, output_size, self.stride, self.padding, self.kernel_size, self.dilation)
            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ <--- HERE
        return F.conv_transpose1d(
            input, self.weight, self.bias, self.stride, self.padding,

Expression of type dots cannot be used in a type expression:

That seems to disagree with the Tuple docs in https://pytorch.org/docs/master/jit_language_reference.html#supported-type. Looks like only fixed-length tuples are supported? If so, would be good to fix that docs entry.

This would explain my question above about everything being typed List[int].

yes. i agree the doc is confusing.. it should be Tuple[T1, T2] instead of Tuple[T1, T2, ...] which means a variable-length tuple, see https://docs.python.org/3/library/typing.html#typing.Tuple

did a bit of research. seems like in fact it is only afffecting Tuple[T, ...] annotation. i checked that the following actually worked so JIT can parse ellipsis correct.

def foo():
            n = torch.ones(16).reshape(2,2,2,2)
            return n[1,...,1]  # equivalent to return n[1,:,:,1]

actually I am not sure if this is necessary --> I guess the reason why you want to use Sequence here is bc _output_padding returns a List[int] but others expect a Tuple[int, ...]. but in fact it is a helper function only for this module. we can change its return .

also if that's the case you can also change the argument types to Tuple[int, ...] as well. ??

did a bit of research. seems like in fact it is only afffecting Tuple[T, ...] annotation. i checked that the following actually worked so JIT can parse ellipsis correct.

def foo():
            n = torch.ones(16).reshape(2,2,2,2)
            return n[1,...,1]  # equivalent to return n[1,:,:,1]