Skip to content

Feature Request: Type hint for Fixed Length Homogeneous Sequences #786

Open
Open
Feature Request: Type hint for Fixed Length Homogeneous Sequences#786
Labels
topic: featureDiscussions about new features for Python's type annotations

Description

@craigh92
craigh92
opened on Feb 11, 2021

Feature

A concise way to hint that a sequence of homogenous types is a set length. i.e The items in the sequence are all of the same type, the sequence is iterable, and cannot grow larger or smaller.

Pitch

Currently, the recommended way to add type hints to fixed-length sequences is to use Tuples 1. i.e

def foo(ten_floats: Tuple[float,float,float,float,float,float,float,float,float,float]):
    ...

For longer lists, this repetition is tedious and prone to error.
It would be nice to have a shorthand for defining homogeneous tuples. e.g

def foo(ten_floats: HomogeneousTuple[float, 10]):
    ...

Although the name Tuple does not signal intent very well. The real thing that we are trying to signal is that this is a sequence of floats of length 10. It does not necessarily have to be a Tuple, it just has to be iterable, and have 10 items, that cannot grow larger or smaller. If I wanted to pass the function a List, this should also pass static type checkers, as long as it has 10 floats.

Possible Implementation

I am not a core python developer, I have never even looked at the implementation of the typing module, and I'm not even that good of a python developer, so please forgive me if this is nonsense.

In Python 3.10 or newer [2] we will be able to use the unpack operator in subscript. So we might be able to do something like:

_t=[float]*10
def foo(ten_floats: Tuple[*_t]):
    ...

Using TypeVars, we could generalize this function to accept 10 of any type (as long as they are all the same type)

T=TypeVar('T')
TenTypeVars=[T]*10
def foo(ten_homogeneous_items: Tuple[*TenTypeVars]):
    ...

Following this logic, perhaps a generic type hint for Fixed Length Homogeneous Sequences could be implemented with

class FixedLengthHomogeneousSequence(Generic[T, N], Tuple[*[T]*N]):
    ...

FixedLengthHomogeneousSequence is a bit wordy. So perhaps FixedList would be a better name.

[2] (I think this is true). Pylance gave me an error saying this was the case. I think it's related to https://www.python.org/dev/peps/pep-0622/

Activity

  1. jp-larose commented on May 5, 2021

    @jp-larose
    jp-larose
    on May 5, 2021

    Experimenting with this idea, I found a possible solution using the existing API.

    Summary

    Create type-hint for a fixed-length homogeneous tuple directly with types.GenericAlias.

    from types import GenericAlias
from typing import TypeVar
T = TypeVar('T')
EightTuple = GenericAlias(tuple, (T,)*8)
eight_ints: EightTuple[int] = (1, 2, 3, 4, 5, 6, 7, 8)
eight_strs: EightTuple[str] = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')

    How I got there

    At first, I tried manipulating tuples directly:

    >>> (int,)*10
(<class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>)
>>> from typing import TypeVar
>>> T = TypeVar('T')
>>> TenTuple = (T,)*10
>>> TenTuple
(~T, ~T, ~T, ~T, ~T, ~T, ~T, ~T, ~T, ~T)

    However, I got stuck at this point because:

    >>> TenTuple[int]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: tuple indices must be integers or slices, not type

    I tried other variations on this theme with typing.Generic, and kept getting the same error.

    I also made a desperate attempt at a tuple metatype, but that failed miserably.

    Then I looked at

    >>> type(tuple[int])
<class 'types.GenericAlias'>

    Which got me thinking, maybe we can just create our own alias type directly:

    >>> from types import GenericAlias
>>> EightTuple = GenericAlias(tuple, (T,)*8)
>>> EightTuple
tuple[~T, ~T, ~T, ~T, ~T, ~T, ~T, ~T]
>>> EightTuple[int]
tuple[int, int, int, int, int, int, int, int]
  2. srittau
    added
    topic: featureDiscussions about new features for Python's type annotations
    on Nov 4, 2021

  3. garrison commented on Jan 24, 2023

    @garrison
    garrison
    on Jan 24, 2023

    In Julia, this type alias is called NTuple:

    julia> NTuple{3,Int}
Tuple{Int64, Int64, Int64}

  4. Ricyteach commented on Jul 5, 2023

    @Ricyteach
    Ricyteach
    on Jul 5, 2023

    Experimenting with this idea, I found a possible solution using the existing API.

    Summary

    Create type-hint for a fixed-length homogeneous tuple directly with types.GenericAlias.

    from types import GenericAlias
from typing import TypeVar
T = TypeVar('T')
EightTuple = GenericAlias(tuple, (T,)*8)
eight_ints: EightTuple[int] = (1, 2, 3, 4, 5, 6, 7, 8)
eight_strs: EightTuple[str] = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')

    Did something change? I am getting:

    error: Variable "test.EightTuple" is not valid as a type  [valid-type]

    (mypy 1.4.1)

  5. jp-larose commented on Jul 11, 2023

    @jp-larose
    jp-larose
    on Jul 11, 2023

    Experimenting with this idea, I found a possible solution using the existing API.

    Summary

    Create type-hint for a fixed-length homogeneous tuple directly with types.GenericAlias.

    from types import GenericAlias
from typing import TypeVar
T = TypeVar('T')
EightTuple = GenericAlias(tuple, (T,)*8)
eight_ints: EightTuple[int] = (1, 2, 3, 4, 5, 6, 7, 8)
eight_strs: EightTuple[str] = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')

    Did something change? I am getting:

    error: Variable "test.EightTuple" is not valid as a type  [valid-type]

    (mypy 1.4.1)

    This was two years a go, so I don't remember exactly how deep I got with this. I seem to recall only playing around with GenericAlias, but not validating the resulting type in mypy. It would be nice for these to validate though. I suspect the issue is that the code has to execute, and mypy only looks at static code, but I'm not 100% sure on that.

  6. jacktose commented on Jan 10, 2024

    @jacktose
    jacktose
    on Jan 10, 2024

    A thought on syntax: I just stumbled on the similar foo: tuple[int, int, int] problem, and my naive/intuitive guess was foo: tuple[int]*3 or foo: tuple[int*3], based on the familiar (7,)*3 syntax.

  7. lou1306 commented on Aug 23, 2024

    @lou1306
    lou1306
    on Aug 23, 2024

    Given that T1 | T2 | ... | Tn is now valid syntax for union types, I think the natural extension for product types (i.e., tuples) would be T1 & T2 & ... & Tn. For very long homogeneous tuples, I'd say either (T,) * n or T ** n would make sense.

  8. Shaked-Q commented on Aug 25, 2024

    @Shaked-Q
    Shaked-Q
    on Aug 25, 2024

    Experimenting with this idea, I found a possible solution using the existing API.

    Summary

    Create type-hint for a fixed-length homogeneous tuple directly with types.GenericAlias.

    from types import GenericAlias
from typing import TypeVar
T = TypeVar('T')
EightTuple = GenericAlias(tuple, (T,)*8)
eight_ints: EightTuple[int] = (1, 2, 3, 4, 5, 6, 7, 8)
eight_strs: EightTuple[str] = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')

    This doesn't work for me. This code does not issue a typing warning:

    from types import GenericAlias
from typing import TypeVar

T = TypeVar('T')
Pair = GenericAlias(tuple, (T,)*2)

def foo(a: Pair[int]) -> None:
    print(a[0])

foo((1, 3, 3))  
# Expected a typing warning ("Expected type 'tuple[int, int]', got 'tuple[int, int, int]' instead"), but did not get one.
# Changing the type hint of `a` in `foo` to 'tuple[int, int]' does issue this warning, as expected.

    I'm using Python 3.10, mypy==1.11.2, PyCharm community 2024.2.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    topic: featureDiscussions about new features for Python's type annotations

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions