wrongly reported typing error in `min` with `key` lambda function and default value when result is Optional · Issue #17221 · python/mypy · GitHub

Bug Report

When using key function in min builtin function, default None value and returning it from a function which has an Optional type, mypy reports a problem where I believe there is none.

To Reproduce

from dataclasses import dataclass
from typing import List

@dataclass
class X:
    x: int

def get_min(vals: List[X]) -> X | None:
    return min(vals, key = lambda tsync: tsync.x, default=None)

result = get_min([X(1), X(2), X(3)])

Expected Behavior

No errors reported.

Actual Behavior

$ mypy b.py --pretty
b.py:11: error: Item "None" of "X | None" has no attribute "x"  [union-attr]
        return min(vals, key = lambda tsync: tsync.x, default=None)
                                             ^~~~~~~
Found 1 error in 1 file (checked 1 source file)

The error goes away if I remove the default=None or when the min is not in a function with X | None return type:

from dataclasses import dataclass
from typing import List

@dataclass
class X:
    x: int

def get_min_1(vals: List[X]) -> X | None:
    return min(vals, key = lambda tsync: tsync.x, default=None)

def get_min_2(vals: List[X]) -> X | None:
    return min(vals, key = lambda tsync: tsync.x) # <- this is fine

vals = [X(1), X(2), X(3)]

result1 = get_min_1(vals)
result2 = get_min_2(vals)
result3 = min(vals, key = lambda tsync: tsync.x, default=None) # <- this is fine

Here, mypy complains only about get_min_1:

$ mypy a.py --pretty
a.py:11: error: Item "None" of "X | None" has no attribute "x"  [union-attr]
        return min(vals, key = lambda tsync: tsync.x, default=None)
                                             ^~~~~~~
Found 1 error in 1 file (checked 1 source file)

Your Environment

Mypy version used: 1.8.0
Mypy command-line flags: none required for reproducting the bug
Mypy configuration options from mypy.ini (and other config files): (no config)
Python version used: 3.11

This is not a stub bug as I expected initially when got bitten by this. min is defined correctly with two different typevars. This is a strange failure of inference.

The following snippet demonstrates the weird inconsistency:

from __future__ import annotations

def foo(x: list[list[int]]) -> list[int] | None:
    reveal_type(min(x, key=len, default=None))  # N: Revealed type is "Union[builtins.list[builtins.int], None]"
    return min(x, key=len, default=None)  # E: Argument "key" to "min" has incompatible type "Callable[[Sized], int]"; expected "Callable[[list[int] | None], SupportsDunderLT[Any] | SupportsDunderGT[Any]]"  [arg-type]

foos: list[list[int]]
reveal_type(min(foos, key=len, default=None))  # N: Revealed type is "Union[builtins.list[builtins.int], None]"
min_foo: list[int] | None = min(foos, key=len, default=None)  # E: Argument "key" to "min" has incompatible type "Callable[[Sized], int]"; expected "Callable[[list[int] | None], SupportsDunderLT[Any] | SupportsDunderGT[Any]]"  [arg-type]

Note that return line produces an arg-type error, but the same expression (!) on the previous line has type assignable to return type. The same happens outside of the function with and without output types.

min is defined in typeshed as

@overload
def min(
    arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, key: None = None
) -> SupportsRichComparisonT: ...
@overload
def min(arg1: _T, arg2: _T, /, *_args: _T, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
@overload
def min(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT: ...
@overload
def min(iterable: Iterable[_T], /, *, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
@overload
def min(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T: ...
@overload
def min(iterable: Iterable[_T1], /, *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ...

The relevant overload is the last one.

Here's a playground link: https://mypy-play.net/?mypy=master&python=3.11&flags=strict&gist=8b209a7e7c9ddf0c03f3f6dfb0153316

Got bitten by this too; the weird thing is that assigning the expression to a (non annotated) name and returning the name works but returning the expression directly errors with Argument "key" to "min" has incompatible type "Callable[[Path], Any]"; expected "Callable[[Path | None], SupportsDunderLT[Any] | SupportsDunderGT[Any]]" [arg-type]

from pathlib import Path
from typing import Callable, Any, Iterable

def min_path_good(paths: Iterable[Path], key: Callable[[Path], Any]) -> Path | None:
    path = min(paths, key=key, default=None)
    return path

def min_path_bad(paths: Iterable[Path], key: Callable[[Path], Any]) -> Path | None:
    return min(paths, key=key, default=None)

Merge branch 'master' into bugfix/pythongh-17221-typevar-union-context

Extend special case for context-based typevar inference to typevar un…

wrongly reported typing error in `min` with `key` lambda function and default value when result is Optional · Issue #17221 · python/mypy · GitHub

Repository navigation

wrongly reported typing error in min with key lambda function and default value when result is Optional #17221

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

wrongly reported typing error in `min` with `key` lambda function and default value when result is Optional · Issue #17221 · python/mypy · GitHub

Repository navigation

wrongly reported typing error in min with key lambda function and default value when result is Optional #17221

Description

Activity

sterliakov commented on Jun 5, 2024

gsakkis commented on Apr 26, 2025

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions