Mappings first type parameter should be covariant

[KotlinIsland]

Attention!

Basedmypy supports this feature

Issue

m1: Mapping[str, object] = {"a": 1}
m2: Mapping[object, object] = m1  # error, lame

• Make Mapping covariant in keys (too). python/typing#273

There are many many issues around about this

backwards compatibility assurance

there is a vary low chance of breaking edge cases of implementations of Mapping that abuse the invariant param:

from typing import *

class BadMap[K, V](Mapping[K, V]):
    def __init__(self, key: K, value: V):
        self.key: K
        self.value: V

    _secret_key: K

    @override
    def __getitem__(self, key: K) -> V:
        """you have to override a method method that takes `K` and make it do something unsafe like store the value"""
        self._secret_value = key
        return self.value

    def get_key(self) -> K:
        return self._secret_key

m: Mapping[str, object] = BadMap("key", "value")
b: Mapping[object, object] = m
b[2]
m.get_value()  # revealed str, actually 2

I believe that this would be extremely rare in real life.

Upvote & Fund

• We're using Polar.sh so you can upvote and help fund this issue.
• We receive the funding once the issue is completed & confirmed by you.
• Thank you in advance for helping prioritize & fund our backlog :^)

[DetachHead]

im hesitant to support this because it's technically unsafe. i've never run into any issues with it in its curent state

[DetachHead]

imo a better solution is to do #413 then create our own Mapping type that utilizes this functionality, to avoid breaking existing usages of Mapping

[beauxq]

A safer way, without having to add new things to type checkers or to the type system, is to use something like this:

@typing.runtime_checkable
class CoMapping(Collection[_KT_co], typing.Protocol, typing.Generic[_KT_co, _VT_co]):
    """ a covariant version of collections.abc.Mapping """
    # Mapping can't be covariant because of __getitem__
    def items(self) -> ItemsView[_KT_co, _VT_co]: ...
    def keys(self) -> KeysView[_KT_co]: ...
    def values(self) -> ValuesView[_VT_co]: ...
    @override
    def __contains__(self, key: object, /) -> bool: ...
    @override
    def __eq__(self, other: object, /) -> bool: ...

somewhat copied from typeshed Mapping
but removing the invariant parts