from typing import Callable, TypeVar, Dict, List, Mapping
from typing_extensions import Protocol

B = TypeVar('B')
C = TypeVar('C')

# Protocol for a substituter that finds and replaces strings in a `B`.
# Given `s: Substituter[B]`, the call `s(m, x)` creates a modified copy
# of `x` where each `a: str` is replaced by `m[a]`.
class Substituter(Protocol[B]):
    def __call__(self, mapping: Mapping[str, str], target: B) -> B: ...

# Substituter for a single string
def str_id_substituter(mapping: Mapping[str, str], target: str) -> str:
    return mapping[target]

# Substituter for all values in a dictionary
def dict_value_substituter(s: Substituter[B]) -> Substituter[Dict[C, B]]:
    def apply(mapping: Mapping[str, str], target: Dict[C, B]) -> Dict[C, B]:
        return dict((k, s(mapping, v)) for k, v in target.items())
    return apply

# Inputs for example
d: Dict[int, str] = {1: 'a'}
m: Mapping[str, str] = {'a': 'b'}

def example() -> Dict[int, str]:
    # Wrong type inferred for return value of dict_value_substituter(...)
    return dict_value_substituter(str_id_substituter)(m, d)

def example_fixed() -> Dict[int, str]:
    # With explicit type annotation, it works
    s: Substituter[Dict[int, str]] = dict_value_substituter(str_id_substituter)
    return s(m, d)

print(example())
print(example_fixed())