cannot infer (or provide) types of lambdas

[bwo]

Consider this file: https://gist.github.com/bwo/077400d43c517ca0b80f2e85f615073e
The output from running mypy is:

comp.py:57: error: Cannot infer type argument 1 of "cfilter"
comp.py:61: error: Revealed type is 'typing.Sequence*[Any]'
comp.py:67: error: Cannot infer type argument 1 of "cmap"
comp.py:68: error: Revealed type is 'def (typing.Sequence*[Any]) -> typing.Sequence*[builtins.int*]'
comp.py:70: error: Revealed type is 'typing.Sequence*[builtins.int*]'
comp.py:72: error: Cannot infer type argument 3 of "comp"

I suspect this is related to the fact that reveal_type(len) and reveal_type(lambda s: len(s)) are, to my surprise, not the same (the latter accepts Any as input, the former requires Sized). According to mypy docs lambdas are subject to bidirectional typechecking, but afaict sufficient information is present in the file given to type the lambdas; nevertheless, they aren't.

[gvanrossum]

Maybe it's because you are also using functools.partial()? IIRC mypy doesn't yet support that very well.

[bwo]

Replacing the partial calls with lambdas (or named functions) doesn't change the output. Also, I'm only using partial in the implementation of the type-overloaded functions, which I thought mypy wouldn't check, and the same inference failure occurs just with comp(lambda x: x + 1, lambda s: len(s)).

[gvanrossum]

Then can you reduce the example to something smaller so there are no distractions from the issue you're reporting? (It should be small enough that you can easily paste it into an issue comment directly.)

[bwo]

from typing import Callable, TypeVar

S = TypeVar('S')
T = TypeVar('T')
U = TypeVar('U')


def comp(g, f):
    # type: (Callable[[T], U], Callable[[S], T]) -> Callable[[S], U]
    def composed(x):
        # type : (S) -> U
        return g(f(x))
    return composed


def test(s):
    # type: (str) -> int

    len_and_inc = comp(lambda i: i + 1, lambda s: len(s))
    x = len_and_inc(s)
    reveal_type(x)
    return x

revealed type is Any. Replacing lambda s: len(s) with len reveals a type of int. Replacing len_and_inc = comp(lambda i: i+ 1, lambda s: len(s)) with just len_and_inc = lambda s: len(s) reveals a type of int as well.

[gvanrossum]

I think this is a deficiency in the "solver". Somewhere the backtracking goes awry. You can work around it by replacing some of the lambdas with defs.

[ilevkivskyi]

FWIW on current master mypy gives a very different output:

test.py:57: error: Unsupported operand types for > ("int" and "T")  [operator]
test.py:61: note: Revealed type is "typing.Sequence[builtins.int]"
test.py:67: error: Argument 1 to "len" has incompatible type "T"; expected "Sized"  [arg-type]
test.py:68: note: Revealed type is "def [T] (typing.Sequence[T`22]) -> typing.Sequence[builtins.int]"
test.py:70: note: Revealed type is "typing.Sequence[builtins.int]"
test.py:72: error: Argument 1 to "len" has incompatible type "S"; expected "Sized"  [arg-type]

The current errors look much better, and it looks like they can be fixed by adding corresponding upper bounds to type variables.