====== Annotations ======
  * https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html
  * https://zestedesavoir.com/tutoriels/954/notions-de-python-avancees/2-functions/2-annotations-signatures/
  * https://docs.python.org/3/library/typing.html
  * https://medium.com/@yothinix/python-type-annotation-and-why-we-need-it-91820a708170

En python il est possible de faire des annotations:

<code python>
def addition(a: int, b: int) -> int:
    return a + b
</code>

Le module **typing** présente une collection de classes pour composer des types. Ce module a été introduit dans Python 3.5, et n’est donc pas disponible dans les versions précédentes du langage.

Dans notre fonction addition, nous voudrions en fait que les int, float et complex soient admis. Nous pouvons pour cela utiliser le type Union du module typing :
<code python>
from typing import Union

Number = Union[int, float, complex]

def addition(a: Number, b: Number) -> Number:
    return a + b
</code>

Nous utilisons ici **Union** mais il en existe d'autres comme par exemple :
  * **List[str]** : Une liste de chaînes de caractères ;
  * **Sequence[str]** :  Une séquence (liste/tuple/etc.) de chaînes de caractères ;
  * **Callable<nowiki>[[str, int], str]</nowiki>** : Un callable prenant deux paramètres de types //str// et //int// respectivement, et retournant un objet //str//

<code python>
def foo(arg: Optional[int] = None) -> None:
    ...
</code>

<code python>
def foo(arg: Optional[List[Union[int, str]]] = None) -> None:
    ...
</code>


<code python>
max_value : int = 10 # Définition d'une variable max_value annotée comme int
min_value : int      # Annotation seule, la variable n'est pas définie dans ce cas
</code>

<code python>
from typing import List
Vector = List[float]

def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]
</code>

<code python>
from typing import Dict, Tuple, Sequence

ConnectionOptions = Dict[str, str]
Address = Tuple[str, int]
Server = Tuple[Address, ConnectionOptions]

def broadcast_message(message: str, servers: Sequence[Server]) -> None:
    ...

# The static type checker will treat the previous type signature as
# being exactly equivalent to this one.
def broadcast_message(
        message: str,
        servers: Sequence[Tuple[Tuple[str, int], Dict[str, str]]]) -> None:
    ...
</code>

<code python>
from typing import Callable

def feeder(get_next_item: Callable[[], str]) -> None:
    # Body

def async_query(on_success: Callable[[int], None],
                on_error: Callable[[int, Exception], None]) -> None:
    # Body
</code>

<code python>
from typing import Any
     # OK

def foo(item: Any) -> int:
    ...
</code>

<code python>
T = TypeVar('T')  # Can be anything
A = TypeVar('A', str, bytes)  # Must be str or bytes

def repeat(x: T, n: int) -> Sequence[T]:
    """Return a list containing n references to x."""
    return [x]*n

def longest(x: A, y: A) -> A:
    """Return the longest of two strings."""
    return x if len(x) >= len(y) else y
</code>

<code python>
def fib(n: int) -> Iterator[int]:
    a, b = 0, 1
    while a < n:
        yield a
        a, b = b, a+b
</code>