在 TypeVar 上绑定 TypeVar 的解决方法？-解网

问：

有没有办法用 Python 的类型提示来表达这个 Scala 代码？

trait List[A] {
  def ::[B >: A](x: B): List[B]
}

我正在努力实现这种事情

class X: pass
class Y(X): pass
class Z(X): pass

xs = MyList(X(), X())  # inferred as MyList[X]
ys = MyList(Y(), Y())  # inferred as MyList[Y]

_ = xs.extended_by(X())  # inferred as MyList[X]
_ = xs.extended_by(Y())  # inferred as MyList[X]

_ = ys.extended_by(X())  # inferred as MyList[X]
_ = ys.extended_by(Y())  # inferred as MyList[Y]
_ = ys.extended_by(Z())  # inferred as MyList[X]

请注意，该类型初始化为，它的类型可以是任何内容。是不可变的。有关更多详细信息，请参阅注释。MyListextended_byMyList

我试过了什么

from __future__ import annotations
from typing import TypeVar, Generic

B = TypeVar('B')
A = TypeVar('A', bound=B)


class MyList(Generic[A]):
    def __init__(*o: A):
        ...

    def extended_by(self, x: B) -> MyList[B]:
        ...

但我明白了（上面是 main.py）

main.py:5：错误：键入变量“main.B“是未绑定
的 main.py:5：注意：（提示：使用”Generic[B]“或”Protocol[B]“基类将”B“绑定到类内） main.py:5：注意：（提示：使用函数签名中的”B“将”B“绑定到函数内部）

Afaict，不允许绑定在.在这种情况下是否有解决方法？TypeVar

Python 类型提示类型边界

@a_guest和扩展它的类型（称为）可以是任何内容。Scala 签名很聪明，因为任何两种类型都会有一个共同的祖先，这里 .如果是的子类，则为，它变得微不足道。如果是的超类，则是。真正聪明的一点是，当既不是超类也不是子类时。然后成为共同的祖先。您已经扩展了它，但 Scala 将其视为其超类的实例。ACBCABACABCCBCB

1赞 joel 7/4/2020

@a_guest因此，在回答您的问题时，它们可以是任何类型

2赞 joel 7/7/2020

@szatkus它是一个静态类型检查的东西。运行时在很大程度上无关紧要

答：

-2赞 Cyrille Pontvieux 4/19/2022 #1

from __future__ import annotations

from typing import (
    TYPE_CHECKING,
    Generic,
    TypeVar,
)

B = TypeVar('B')
A = TypeVar('A')


class MyList(Generic[A]):
    def __init__(*o: A):
        ...

    def extended_by(self, x: B) -> MyList[B]:
        ...


class Y:
    ...


class X:
    ...


ys = MyList(Y(), Y())
xs = ys.extended_by(X())
if TYPE_CHECKING:
    reveal_locals()

这会产生：

test.py:32: note: Revealed local types are:
test.py:32: note:     xs: test.MyList[test.X*]
test.py:32: note:     ys: test.MyList[test.Y*]

我不明白和之间的联系。你能举一个例子吗，比如类，这样我就可以更新我的答案了？ABYX

from typing import TypeVar, Generic
A = TypeVar("A", covariant=True)
B = TypeVar("B")

class MyList(Generic[A]):
    def __init__(*objects: A) -> None: ...
    def extended_by(self, other: B) -> MyList[A | B]: ...

class X: pass
class Y(X): pass
class Z(X): pass


xs = MyList(X(), X())  # inferred as MyList[X]
ys = MyList(Y(), Y())  # inferred as MyList[Y]

reveal_type(xs.extended_by(X())) # inferred as MyList[X]
reveal_type(xs.extended_by(Y())) # inferred as MyList[X]

reveal_type(ys.extended_by(X()))  # inferred as MyList[X]
reveal_type(ys.extended_by(Y()))  # inferred as MyList[Y]
reveal_type(ys.extended_by(Z()))  # inferred as MyList[Y|Z]
# MyList[Y|Z] is a subtype of MyList[X]

如果是不可变的，则其类型变量很可能是协变的。这意味着它是的子类。我冒昧地使您的泛型参数协变，这也将使该方法的实现更容易。MyListMyList[X]MyList[Y]extended_by

注意：如果您必须使用 Python<3.10，请确保替换为 .|Union

注 2：这与方法相同，例如，请参阅 Typeshed 中的代码。list.__add__

上一个：TypeVar（'T'， A， B）和 TypeVar（'T'， bound=Union[A， B]）之间的区别

下一个：在 Scala 中，a += b 何时变成 a = a + b？

在 TypeVar 上绑定 TypeVar 的解决方法？

Workaround for TypeVar bound on a TypeVar?

评论

评论