Type hint two function parameters to constrain them both to the same type and reject types like numpy.ndarray which do not support boolean comparison

Question

I would like to annotate both parameters of a function – supposed to perform simple comparison between them – in order to indicate that their types should be the same and should support simple equality comparison.

The second part should be normally trivial, as every type implicitly inherits from object which promises to support this:

class object:

    def __eq__(self, value: object, /) -> bool: ...

and yet numpy.ndarray does not, because its parent class overrides the method as

class _ArrayOrScalarCommon:

    def __eq__(self, other: Any) -> Any: ...

in order to return arrays of booleans with the shape of the argument instead of a unique boolean. This should already be marked as incompatible override as it represents a violation of the LSP. Nevertheless, I want to enforce correctness of the function at type level so that users know that it should not be used with two arguments of type numpy.ndarray or of different types.

Simple protocol annotation does not work:

from typing import Protocol
from numpy import array


class SupportsSimpleComparison(Protocol):

    def __eq__(self, other: object, /) -> bool: ...


def check_equal(a: SupportsSimpleComparison, b: SupportsSimpleComparison) -> bool:
    return a == b

# no errors reported from pyright
check_equal(array([0, 0, 0]), array([0, 0, 1]))
check_equal(1.0, "hello world")

Nor does making the function generic with a type variable bound to the protocol:

T = TypeVar("T", bound=SupportsSimpleComparison)


def check_equal(a: T, b: T) -> bool:
    return a == b


# no errors reported from pyright
check_equal(array([0, 0, 0]), array([0, 0, 1]))
check_equal(1.0, "hello world")

ndarray's choice to use Any as the return type fundamentally disables the type check. In general you are allowed to pass an Any as a bool, it would be very frustrating if you couldn't. Without updating numpy, I don't know if there is a solution. You might need to fall back to runtime validation. — Gaberocksall
– Gaberocksall, Commented Sep 16 at 10:04

dROOOze · Accepted Answer · 2025-09-16 20:58:44Z

3

I'm unsure of your problem scope, but I believe that can just do this (see mypy and pyright):

from typing_extensions import Protocol, TypeAlias, deprecated, overload

array: TypeAlias = list[int]

class ExactType[T](Protocol):
    @property  # type: ignore
    def __class__(self, /) -> type[T]: ... 
    @__class__.setter
    def __class__(self, Class: type[T], /) -> None: ...

@overload
@deprecated("arrays are not supported")
def check_equal(a: array, b: array) -> bool: ...
@overload
def check_equal[T](a: ExactType[T], b: T) -> bool: ...
def check_equal[T](a: ExactType[T], b: T) -> bool:
    return a == b

from typing import TypeAlias
array: TypeAlias = list[int]

check_equal(array([0, 0, 0]), array([0, 0, 1]))  # Error (Deprecated)
check_equal(1.0, "hello world")                  # Error
check_equal(1, 2)                                # OK
check_equal("hello", "world")                    # OK

The second overload of check_equal works because ExactType[T] forces an invariant solution for T to be solved first when check_equal receives an argument for a.

edited Sep 16 at 20:58

answered Sep 16 at 20:47

dROOOze

4,1941 gold badge12 silver badges23 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Vexx23 Sep 18 at 8:16

This is very promising, I have tried adapting it to python 3.10. It correctly marks two errors (reportDeprecated and reportArgumentType)

InSync · Accepted Answer · 2025-09-17 14:59:04Z

3

There is a way to make it works, but it relies on a not-very-popular trick¹ that might be (formally) removed from the type system: Any is assignable to Never.

Never is the bottom type, which means the only (fully static) subtype of it is itself. However, Any is also assignable to Never, being a non-fully-static type that can materialize to Never.

That means we can define a protocol that only types with "weird" __bool__ will match:

class HasWeirdDunderBoolOverride(Protocol):
    def __bool__(self, other: Any, /) -> Never: ...

...then use it in a deprecated overload:

_(playground)

@overload
@deprecated('Objects have weird __bool__ overrides')
def check_equal(a: HasWeirdDunderBoolOverride, b: HasWeirdDunderBoolOverride) -> Any: ...
@overload
def check_equal(a: SupportsSimpleComparison, b: SupportsSimpleComparison) -> bool: ...

def check_equal(a: object, b: object) -> bool:
    return a == b

check_equal(array([0, 0, 0]), array([0, 0, 1]))  # error: Objects have weird __bool__ overrides
check_equal(1.0, 'hello world')                  # fine

_{1: The author of that post, Joren Hammudoglu, is a Numpy maintainer.}

edited Sep 17 at 14:59

answered Sep 16 at 13:27

InSync

12.2k5 gold badges22 silver badges60 bronze badges

5 Comments

Vexx23 Sep 18 at 7:07

Interesting, even though not what I was looking for, as it implies knowing the signature I want to reject, as opposed to enforcing the one I need. I should probably have mentioned that I needed my function to work with python 3.10.

InSync Sep 18 at 14:50

@Vexx23 You can either use NoReturn (added in 3.6.2) instead of Never (added in 3.11), or import Never from typing_extension.

InSync Sep 18 at 14:51

Also, in which case does this not work?

Vexx23 Sep 18 at 16:12

This check_equal(1.0, 'hello world')

InSync Sep 18 at 16:53

1.0 == 'hello world' isn't an error per se (consider also indirect calls such as def f(a: object, b: object): return check_equal(a, b) / f(1.0, 'hello world')), but, if you want to, you can combine this approach with @dROOOze's.

Collectives™ on Stack Overflow

Type hint two function parameters to constrain them both to the same type and reject types like numpy.ndarray which do not support boolean comparison

2 Answers 2

1 Comment

5 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

5 Comments

Your Answer

Sign up or log in

Post as a guest

Related