26.1. "typing" --- 型ヒントのサポート
*************************************

バージョン 3.5 で追加.

**ソースコード:** Lib/typing.py

注釈:

  typing モジュールは *暫定的に* 標準ライブラリに追加されました。マイ
  ナーリリースの間でもコアデベロッパーが必要だと判断した場合は、新機能
  の追加や API の変更がなされることがあります。

======================================================================

このモジュールは **PEP 484** と **PEP 526** によって規定された型ヒント
をサポートします。最も基本的なサポートとして "Any"、 "Union"、 "Tuple"
、 "Callable"、 "TypeVar" および "Generic" 型を含みます。完全な仕様は
**PEP 484** を参照してください。型ヒントの簡単な導入は **PEP 483** を
参照してください。

以下の関数は文字列を受け取って文字列を返す関数で、次のようにアノテーシ
ョンがつけられます:

   def greeting(name: str) -> str:
       return 'Hello ' + name

関数 "greeting" で、実引数 "name" の型は "str" であり、返り値の型は
"str" であることが期待されます。サブタイプも実引数として許容されます。


26.1.1. 型エイリアス
====================

型エイリアスは型をエイリアスに代入することで定義されます。この例では
"Vector" と "List[float]" は交換可能な同義語として扱われます。

   from typing import List
   Vector = List[float]

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

   # typechecks; a list of floats qualifies as a Vector.
   new_vector = scale(2.0, [1.0, -4.2, 5.4])

型エイリアスは複雑な型シグネチャを単純化するのに有用です。例えば:

   from typing import Dict, Tuple, List

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

   def broadcast_message(message: str, servers: List[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: List[Tuple[Tuple[str, int], Dict[str, str]]]) -> None:
       ...

型ヒントとしての "None" は特別なケースであり、 "type(None)" によって置
き換えられます。


26.1.2. NewType
===============

異なる型を作るためには "NewType()" ヘルパー関数を使います:

   from typing import NewType

   UserId = NewType('UserId', int)
   some_id = UserId(524313)

静的型検査器は新しい型を元々の型のサブクラスのように扱います。このこと
は論理的な誤りを見つけることを支援するのに有用です。

   def get_user_name(user_id: UserId) -> str:
       ...

   # typechecks
   user_a = get_user_name(UserId(42351))

   # does not typecheck; an int is not a UserId
   user_b = get_user_name(-1)

"UserId" 型の変数についても全ての "int" についての演算を行うことが出来
ます、しかしその結果は常に "int" 型になります。これは "int" が期待され
るところに "UserId" を渡すことを許します、しかし誤った方法で "UserId"
を作ってしまうことを防ぎます。

   # 'output' is of type 'int', not 'UserId'
   output = UserId(23413) + UserId(54341)

これらのチェックは静的型検査器のみによって強制されるということに注意し
てください。実行時に "Derived = NewType('Derived', Base)" という文は渡
された仮引数をただちに返す "Derived" 関数を作ります。つまり
"Derived(some_value)" という式は新しいクラスを作ることはなく、通常の関
数呼び出し以上のオーバーヘッドがないということを意味します。

より正確に言うと、式 "some_value is Derived(some_value)" は実行時に常
に真を返します。

これは "Derived" のサブタイプを作ることが出来ないということも意味して
います。"Derived" は実行時には恒等関数であり、実際の型ではないからです
:

   from typing import NewType

   UserId = NewType('UserId', int)

   # Fails at runtime and does not typecheck
   class AdminUserId(UserId): pass

しかし、 'derived' である "NewType" をもとにした "NewType()" は作るこ
とが出来ます:

   from typing import NewType

   UserId = NewType('UserId', int)

   ProUserId = NewType('ProUserId', UserId)

そして "ProUserId" に対する型検査は期待通りに動作します。

詳細は **PEP 484** を参照。

注釈:

  型エイリアスの使用は二つの型が互いに *等価* だと宣言している、という
  ことを思い出してください。 "Alias = Original" とすると、静的型検査器
  は "Alias" をすべての場合において "Original" と *完全に等価* なもの
  として扱います。これは複雑な型シグネチャを単純化したい時に有用です。
  これに対し、 "NewType" はある型をもう一方の型の *サブタイプ* として
  宣言します。 "Derived = NewType('Derived', Original)" とすると静的型
  検査器は "Derived" を "Original" の *サブクラス* として扱います。つ
  まり "Original" 型の値は "Derived" 型の値が期待される場所で使うこと
  が出来ないということです。これは論理的な誤りを最小の実行時のコストで
  防ぎたい時に有用です。

バージョン 3.5.2 で追加.


26.1.3. 呼び出し可能オブジェクト
================================

特定のシグネチャのコールバック関数であることが期待されるフレームワーク
では "Callable[[Arg1Type, Arg2Type], ReturnType]" のように使って型ヒン
トを与えられます。

例えば:

   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

型ヒントの実引数の型を ellipsis で置き換えることで呼び出しシグニチャを
指定せずに callable の戻り値の型を宣言することができます:
"Callable[..., ReturnType]"。


26.1.4. ジェネリクス
====================

コンテナ内のオブジェクトについての型情報は一般的な方法では静的に推論出
来ないため、抽象基底クラスが拡張され、コンテナの要素に対して期待される
型を示すために添字表記をサポートするようになりました。

   from typing import Mapping, Sequence

   def notify_by_email(employees: Sequence[Employee],
                       overrides: Mapping[str, str]) -> None: ...

ジェネリクスは、 typing にある "TypeVar" と呼ばれる新しいファクトリを
使ってパラメータ化することができます。

   from typing import Sequence, TypeVar

   T = TypeVar('T')      # Declare type variable

   def first(l: Sequence[T]) -> T:   # Generic function
       return l[0]


26.1.5. ユーザー定義のジェネリック型
====================================

ユーザー定義のクラスはジェネリッククラスとして定義できます。

   from typing import TypeVar, Generic
   from logging import Logger

   T = TypeVar('T')

   class LoggedVar(Generic[T]):
       def __init__(self, value: T, name: str, logger: Logger) -> None:
           self.name = name
           self.logger = logger
           self.value = value

       def set(self, new: T) -> None:
           self.log('Set ' + repr(self.value))
           self.value = new

       def get(self) -> T:
           self.log('Get ' + repr(self.value))
           return self.value

       def log(self, message: str) -> None:
           self.logger.info('%s: %s', self.name, message)

"Generic[T]" を基底クラスとすることで "LoggedVar" クラスは一つの型引数
"T" をとることを定義します。これはまたこのクラスの中で "T" を型として
有効にします。

基底クラス "Generic" は "LoggedVar[t]" が型として有効になるように
"__getitem__()" を定義したメタクラスを利用します。

   from typing import Iterable

   def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:
       for var in vars:
           var.set(0)

ジェネリック型は任意の数の型変数をとることが出来ます、また型変数に制約
をつけることが出来ます:

   from typing import TypeVar, Generic
   ...

   T = TypeVar('T')
   S = TypeVar('S', int, str)

   class StrangePair(Generic[T, S]):
       ...

"Generic" の引数のそれぞれの型変数は別のものでなければなりません。この
ため次は無効です:

   from typing import TypeVar, Generic
   ...

   T = TypeVar('T')

   class Pair(Generic[T, T]):   # INVALID
       ...

"Generic" を用いて多重継承することが出来ます:

   from typing import TypeVar, Generic, Sized

   T = TypeVar('T')

   class LinkedList(Sized, Generic[T]):
       ...

ジェネリッククラスを継承するとき、いくつかの型変数を固定することが出来
ます:

   from typing import TypeVar, Mapping

   T = TypeVar('T')

   class MyDict(Mapping[str, T]):
       ...

この場合では "MyDict" は一つの仮引数 "T" をとります。

型引数を指定せずにジェネリッククラスを使う場合、それぞれの型引数に
"Any" を与えられたものとして扱います。 次の例では、"MyIterable" はジェ
ネリックではありませんが "Iterable[Any]" を暗黙的に継承しています:

   from typing import Iterable

   class MyIterable(Iterable): # Same as Iterable[Any]

ユーザ定義のジェネリック型エイリアスもサポートされています。例:

   from typing import TypeVar, Iterable, Tuple, Union
   S = TypeVar('S')
   Response = Union[Iterable[S], int]

   # Return type here is same as Union[Iterable[str], int]
   def response(query: str) -> Response[str]:
       ...

   T = TypeVar('T', int, float, complex)
   Vec = Iterable[Tuple[T, T]]

   def inproduct(v: Vec[T]) -> T: # Same as Iterable[Tuple[T, T]]
       return sum(x*y for x, y in v)

"Generic" に用いられているメタクラスは "abc.ABCMeta" のサブクラスです
。 ジェネリッククラスは抽象メソッドや抽象プロパティを含めることで抽象
基底クラスになれ、ジェネリッククラスはメタクラスの衝突を起こすことなく
基底クラスに抽象基底クラスをとれます。 ジェネリックメタクラスはサポー
トされません。 パラメータ化を行うジェネリクスの結果はキャッシュされて
いて、 typing モジュールのほとんどの型はハッシュ化でき、等価比較できま
す。


26.1.6. "Any" 型
================

"Any" は特別な種類の型です。静的型検査器はすべての型を "Any" と互換と
して扱い、 "Any" をすべての型と互換として扱います。

つまり、 "Any" 型の値に対し任意の演算やメソッド呼び出しができ、任意の
変数に代入できるということです。

   from typing import Any

   a = None    # type: Any
   a = []      # OK
   a = 2       # OK

   s = ''      # type: str
   s = a       # OK

   def foo(item: Any) -> int:
       # Typechecks; 'item' could be any type,
       # and that type might have a 'bar' method
       item.bar()
       ...

"Any" 型の値をより詳細な型に代入する時に型検査が行われないことに注意し
てください。例えば、静的型検査器は "a" を "s" に代入する時、"s" が
"str" 型として宣言されていて実行時に "int" の値を受け取るとしても、エ
ラーを報告しません。

さらに、返り値や引数の型のないすべての関数は暗黙的に "Any" を使用しま
す。

   def legacy_parser(text):
       ...
       return data

   # A static type checker will treat the above
   # as having the same signature as:
   def legacy_parser(text: Any) -> Any:
       ...
       return data

この挙動により、動的型付けと静的型付けが混在したコードを書かなければな
らない時に "Any" を *非常口* として使用することができます。

"Any" の挙動と "object" の挙動を対比しましょう。 "Any" と同様に、すべ
ての型は "object" のサブタイプです。しかしながら、 "Any" と異なり、逆
は成り立ちません: "object" はすべての他の型のサブタイプでは *ありませ
ん*。

これは、ある値の型が "object" のとき、型検査器はこれについてのほとんど
すべての操作を拒否し、これをより特殊化された変数に代入する (または返り
値として利用する) ことは型エラーになることを意味します。例えば:

   def hash_a(item: object) -> int:
       # Fails; an object does not have a 'magic' method.
       item.magic()
       ...

   def hash_b(item: Any) -> int:
       # Typechecks
       item.magic()
       ...

   # Typechecks, since ints and strs are subclasses of object
   hash_a(42)
   hash_a("foo")

   # Typechecks, since Any is compatible with all types
   hash_b(42)
   hash_b("foo")

"object" は、ある値が型安全な方法で任意の型として使えることを示すため
に使用します。 "Any" はある値が動的に型付けられることを示すために使用
します。


26.1.7. クラス、関数、およびデコレータ
======================================

このモジュールでは以下のクラス、関数とデコレータを定義します:

class typing.TypeVar

   型変数です。

   使い方:

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

   型変数は主として静的型検査器のために存在します。型変数はジェネリッ
   ク型やジェネリック関数の定義の引数として役に立ちます。ジェネリック
   型についての詳細は Generic クラスを参照してください。ジェネリック関
   数は以下のように動作します:

      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

   後者の例のシグネチャは本質的に "(str, str) -> str" と "(bytes,
   bytes) -> bytes" のオーバーロードです。もし引数が "str" のサブクラ
   スのインスタンスの場合、返り値は普通の "str" であることに注意して下
   さい。

   実行時に、"isinstance(x, T)" は "TypeError" を送出するでしょう。一
   般的に、"isinstance()" と "issubclass()" は型に対して使用するべきで
   はありません。

   型変数は "covariant=True" または "contravariant=True" を渡すことに
   よって共変または反変であることを示せます。詳細は **PEP 484** を参照
   して下さい。デフォルトの型変数は不変です。あるいは、型変数は
   "bound=<type>" を使うことで上界を指定することが出来ます。これは、型
   変数に (明示的または非明示的に) 代入された実際の型が境界の型のサブ
   クラスでなければならないということを意味します、**PEP 484** も参照
   。

class typing.Generic

   ジェネリック型のための抽象基底クラスです。

   ジェネリック型は典型的にはこのクラスを1つ以上の型変数によってインス
   タンス化したものを継承することによって宣言されます。例えば、ジェネ
   リックマップ型は次のように定義することが出来ます:

      class Mapping(Generic[KT, VT]):
          def __getitem__(self, key: KT) -> VT:
              ...
              # Etc.

   このクラスは次のように使用することが出来ます:

      X = TypeVar('X')
      Y = TypeVar('Y')

      def lookup_name(mapping: Mapping[X, Y], key: X, default: Y) -> Y:
          try:
              return mapping[key]
          except KeyError:
              return default

class typing.Type(Generic[CT_co])

   "C" と注釈が付けされた変数は "C" 型の値を受理します。一方で
   "Type[C]" と注釈が付けられた変数は、そのクラス自身を受理します --
   具体的には、それは "C" の *クラスオブジェクト* を受理します。例:

      a = 3         # Has type 'int'
      b = int       # Has type 'Type[int]'
      c = type(a)   # Also has type 'Type[int]'

   "Type[C]" は共変であることに注意してください:

      class User: ...
      class BasicUser(User): ...
      class ProUser(User): ...
      class TeamUser(User): ...

      # Accepts User, BasicUser, ProUser, TeamUser, ...
      def make_new_user(user_class: Type[User]) -> User:
          # ...
          return user_class()

   "Type[C]" が共変だということは、 "C" の全てのサブクラスは、 "C" と
   同じシグネチャのコンストラクタとクラスメソッドを実装すべきだという
   ことになります。 型チェッカーはこの規則への違反に印を付けるべきです
   が、サブクラスでのコンストラクタ呼び出しで、指定された基底クラスの
   コンストラクタ呼び出しに適合するものは許可すべきです。 この特別な場
   合を型チェッカーがどう扱うべきかについては、 **PEP 484** の将来のバ
   ージョンで変更されるかもしれません。

   "Type" で許されているパラメータは、クラス、 "Any" 、 型変数 あるい
   は、それらの直和型だけです。 例えば次のようになります:

      def new_non_team_user(user_class: Type[Union[BaseUser, ProUser]]): ...

   "Type[Any]" は "Type" と等価で、同様に "Type" は "type" と等価です
   。"type" は Python のメタクラス階層のルートです。

   バージョン 3.5.2 で追加.

class typing.Iterable(Generic[T_co])

   "collections.abc.Iterable" のジェネリック版です。

class typing.Iterator(Iterable[T_co])

   "collections.abc.Iterator" のジェネリック版です。

class typing.Reversible(Iterable[T_co])

   "collections.abc.Reversible" のジェネリック版です。

class typing.SupportsInt

   抽象メソッド "__int__" を備えた ABC です。

class typing.SupportsFloat

   抽象メソッド "__float__" を備えた ABC です。

class typing.SupportsComplex

   抽象メソッド "__complex__" を備えた ABC です。

class typing.SupportsBytes

   抽象メソッド "__bytes__" を備えた ABC です。

class typing.SupportsAbs

   返り値の型と共変な抽象メソッド "__abs__" を備えた ABC です。

class typing.SupportsRound

   返り値の型と共変な抽象メソッド "__round__" を備えた ABC です。

class typing.Container(Generic[T_co])

   "collections.abc.Container" のジェネリック版です。

class typing.Hashable

   "collections.abc.Hashable" へのエイリアス

class typing.Sized

   "collections.abc.Sized" へのエイリアス

class typing.Collection(Sized, Iterable[T_co], Container[T_co])

   "collections.abc.Collection" のジェネリック版です。

   バージョン 3.6 で追加.

class typing.AbstractSet(Sized, Collection[T_co])

   "collections.abc.Set" のジェネリック版です。

class typing.MutableSet(AbstractSet[T])

   "collections.abc.MutableSet" のジェネリック版です。

class typing.Mapping(Sized, Collection[KT], Generic[VT_co])

   "collections.abc.Mapping" のジェネリック版です。

class typing.MutableMapping(Mapping[KT, VT])

   "collections.abc.MutableMapping" のジェネリック版です。

class typing.Sequence(Reversible[T_co], Collection[T_co])

   "collections.abc.Sequence" のジェネリック版です。

class typing.MutableSequence(Sequence[T])

   "collections.abc.MutableSequence" のジェネリック版です。

class typing.ByteString(Sequence[int])

   "collections.abc.ByteString" のジェネリック版です。

   この型は "bytes" と "bytearray" 、 "memoryview" を表します。

   この型の省略形として、 "bytes" を上に挙げた任意の型の引数にアノテー
   ションをつけることに使えます。

class typing.Deque(deque, MutableSequence[T])

   "collections.deque" のジェネリック版です。

   バージョン 3.6.1 で追加.

class typing.List(list, MutableSequence[T])

   "list" のジェネリック版です。返り値の型のアノテーションをつけること
   に便利です。引数にアノテーションをつけるためには、"Mapping" や
   "Sequence" 、 "AbstractSet" のような抽象コレクション型を使うことが
   好ましいです。

   この型は以下のように使うことが出来ます:

      T = TypeVar('T', int, float)

      def vec2(x: T, y: T) -> List[T]:
          return [x, y]

      def keep_positives(vector: Sequence[T]) -> List[T]:
          return [item for item in vector if item > 0]

class typing.Set(set, MutableSet[T])

   "builtins.set" のジェネリック版です。

class typing.FrozenSet(frozenset, AbstractSet[T_co])

   "builtins.frozenset" のジェネリック版です。

class typing.MappingView(Sized, Iterable[T_co])

   "collections.abc.MappingView" のジェネリック版です。

class typing.KeysView(MappingView[KT_co], AbstractSet[KT_co])

   "collections.abc.KeysView" のジェネリック版です。

class typing.ItemsView(MappingView, Generic[KT_co, VT_co])

   "collections.abc.ItemsView" のジェネリック版です。

class typing.ValuesView(MappingView[VT_co])

   "collections.abc.ValuesView" のジェネリック版です。

class typing.Awaitable(Generic[T_co])

   "collections.abc.Awaitable" のジェネリック版です。

class typing.Coroutine(Awaitable[V_co], Generic[T_co T_contra, V_co])

   "collections.abc.Coroutine" のジェネリック版です。 変性と型変数の順
   序は "Generator" のものと対応しています。例えば次のようになります:

      from typing import List, Coroutine
      c = None # type: Coroutine[List[str], str, int]
      ...
      x = c.send('hi') # type: List[str]
      async def bar() -> None:
          x = await c # type: int

class typing.AsyncIterable(Generic[T_co])

   "collections.abc.AsyncIterable" のジェネリック版です。

class typing.AsyncIterator(AsyncIterable[T_co])

   "collections.abc.AsyncIterator" のジェネリック版です。

class typing.ContextManager(Generic[T_co])

   "contextlib.AbstractContextManager" のジェネリック版です。

   バージョン 3.6 で追加.

class typing.AsyncContextManager(Generic[T_co])

   抽象メソッド "__aenter__()" と "__aexit__()" を備えた ABC です。

   バージョン 3.6 で追加.

class typing.Dict(dict, MutableMapping[KT, VT])

   "dict" のジェネリック版です。この型の使い方は以下の通りです:

      def get_position_in_index(word_list: Dict[str, int], word: str) -> int:
          return word_list[word]

class typing.DefaultDict(collections.defaultdict, MutableMapping[KT, VT])

   "collections.defaultdict" のジェネリック版です。

   バージョン 3.5.2 で追加.

class typing.Counter(collections.Counter, Dict[T, int])

   "collections.Counter" のジェネリック版です。

   バージョン 3.6.1 で追加.

class typing.ChainMap(collections.ChainMap, MutableMapping[KT, VT])

   "collections.ChainMap" のジェネリック版です。

   バージョン 3.6.1 で追加.

class typing.Generator(Iterator[T_co], Generic[T_co, T_contra, V_co])

   ジェネレータはジェネリック型 "Generator[YieldType, SendType,
   ReturnType]" によってアノテーションを付けられます。例えば:

      def echo_round() -> Generator[int, float, str]:
          sent = yield 0
          while sent >= 0:
              sent = yield round(sent)
          return 'Done'

   typing モジュールの多くの他のジェネリクスと違い "Generator" の
   "SendType" は共変や不変ではなく、反変として扱われることに注意してく
   ださい。

   もしジェネレータが値を返すだけの場合は、 "SendType" と "ReturnType"
   に "None" を設定してください:

      def infinite_stream(start: int) -> Generator[int, None, None]:
          while True:
              yield start
              start += 1

   代わりに、ジェネレータを "Iterable[YieldType]" や
   "Iterator[YieldType]" という返り値の型でアノテーションをつけること
   もできます:

      def infinite_stream(start: int) -> Iterator[int]:
          while True:
              yield start
              start += 1

class typing.AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra])

   非同期ジェネレータはジェネリック型 "AsyncGenerator[YieldType,
   SendType]" によってアノテーションを付けられます。例えば:

      async def echo_round() -> AsyncGenerator[int, float]:
          sent = yield 0
          while sent >= 0.0:
              rounded = await round(sent)
              sent = yield rounded

   通常のジェネレータと違って非同期ジェネレータは値を返せないので、
   "ReturnType" 型引数はありません。"Generator" と同様に、"SendType"
   は反変的に振る舞います。

   ジェネレータが値を yield するだけなら、"SendType" を "None" にしま
   す:

      async def infinite_stream(start: int) -> AsyncGenerator[int, None]:
          while True:
              yield start
              start = await increment(start)

   あるいは、ジェネレータが "AsyncIterable[YieldType]" と
   "AsyncIterator[YieldType]" のいずれかの戻り値型を持つとアノテートし
   ます:

      async def infinite_stream(start: int) -> AsyncIterator[int]:
          while True:
              yield start
              start = await increment(start)

   バージョン 3.5.4 で追加.

class typing.Text

   "Text" は "str" のエイリアスです。これは Python 2 のコードの前方互
   換性を提供するために設けられています: Python 2 では "Text" は
   "unicode" のエイリアスです。

   "Text" は Python 2 と Python 3 の両方と互換性のある方法で値が
   unicode 文字列を含んでいなければならない場合に使用してください。

      def add_unicode_checkmark(text: Text) -> Text:
          return text + u' \u2713'

   バージョン 3.5.2 で追加.

class typing.IO
class typing.TextIO
class typing.BinaryIO

   ジェネリック型 "IO[AnyStr]" とそのサブクラスの "TextIO(IO[str])" お
   よび "BinaryIO(IO[bytes])" は、 "open()" 関数が返すような I/O スト
   リームの型を表します。

class typing.Pattern
class typing.Match

   これらの型エイリアスは "re.compile()" と "re.match()" の返り値の型
   に対応します。 これらの型 (と対応する関数) は "AnyStr" についてジェ
   ネリックで、"Pattern[str]" 、 "Pattern[bytes]" 、 "Match[str]" 、
   "Match[bytes]" と書くことで具体型にできます。

class typing.NamedTuple

   namedtuple の型付き版です。

   使い方:

      class Employee(NamedTuple):
          name: str
          id: int

   これは次と等価です:

      Employee = collections.namedtuple('Employee', ['name', 'id'])

   フィールドにデフォルト値を与えるにはクラス本体で代入してください:

      class Employee(NamedTuple):
          name: str
          id: int = 3

      employee = Employee('Guido')
      assert employee.id == 3

   デフォルト値のあるフィールドはデフォルト値のないフィールドの後でな
   ければなりません。

   結果としてできるクラスは二つの追加の属性を持ちます。一つは
   "_field_types" で、フィールド名を型に結びつける辞書です。 もう一つ
   は "_field_defaults" で、フィールド名をデフォルト値に結びつける辞書
   です。 (フィールド名は namedtuple API の一つである "_fields" 属性に
   あります。)

   "NamedTuple" のサブクラスは docstring やメソッドも持てます:

      class Employee(NamedTuple):
          """Represents an employee."""
          name: str
          id: int = 3

          def __repr__(self) -> str:
              return f'<Employee {self.name}, id={self.id}>'

   後方互換な使用法:

      Employee = NamedTuple('Employee', [('name', str), ('id', int)])

   バージョン 3.6 で変更: **PEP 526** 変数アノテーションのシンタックス
   が追加されました。

   バージョン 3.6.1 で変更: デフォルト値、メソッド、ドキュメンテーショ
   ン文字列への対応が追加されました。

typing.NewType(typ)

   異なる型であることを型チェッカーに教えるためのヘルパー関数です。
   NewType を参照してください。 実行時には、その引数を返す関数を返しま
   す。 使い方は次のようになります:

      UserId = NewType('UserId', int)
      first_user = UserId(1)

   バージョン 3.5.2 で追加.

typing.cast(typ, val)

   値をある型にキャストします。

   これは値を変更せずに返します。型検査器にこれは返り値の型が指定され
   た型を持っていることを知らせますが、故意に実行時に何も検査しません
   。(これを出来る限り速く行いたかったのです。)

typing.get_type_hints(obj[, globals[, locals]])

   関数、メソッド、モジュールまたはクラスのオブジェクトの型ヒントを含
   む辞書を返します。

   この辞書はたいてい "obj.__annotations__" と同じものです。 それに加
   えて、文字列リテラルにエンコードされた順方向参照は "globals" 名前空
   間および "locals" 名前空間で評価されます。 必要であれば、 "None" と
   等価なデフォルト値が設定されている場合に、関数とメソッドのアノテー
   ションに "Optional[t]" が追加されます。 クラス "C" については、
   "C.__mro__" の逆順に沿って全ての "__annotations__" を合併して構築さ
   れた辞書を返します。

@typing.overload

   "@overload" デコレータを使うと、引数の型の複数の組み合わせをサポー
   トする関数やメソッドを書けるようになります。 "@overload" 付きの定義
   を並べた後ろに、(同じ関数やメソッドの) "@overload" 無しの定義が来な
   ければなりません。 "@overload" 付きの定義は型チェッカーのためでしか
   ありません。 というのも、 "@overload" 付きの定義は "@overload" 無し
   の定義で上書きされるからです。 後者は実行時に使われますが、型チェッ
   カーからは無視されるべきなのです。 実行時には、 "@overload" 付きの
   関数を直接呼び出すと "NotImplementedError" を送出します。 次のコー
   ドはオーバーロードを使うことでユニオン型や型変数を使うよりもより正
   確な型が表現できる例です:

      @overload
      def process(response: None) -> None:
          ...
      @overload
      def process(response: int) -> Tuple[int, str]:
          ...
      @overload
      def process(response: bytes) -> str:
          ...
      def process(response):
          <actual implementation>

   詳細と他の型付け意味論との比較は **PEP 484** を参照してください。

@typing.no_type_check

   アノテーションが型ヒントでないことを示すデコレータです。

   これはクラス *decorator* または関数 *decorator* として動作します。
   クラス *decorator* として動作する場合は、そのクラス内に定義されたす
   べてのメソッドに対して再帰的に適用されます。（ただしスーパークラス
   やサブクラス内に定義されたメソッドには適用されません。）

   これは関数を適切に変更します。

@typing.no_type_check_decorator

   別のデコレータに "no_type_check()" の効果を与えるデコレータです。

   これは何かの関数をラップするデコレータを "no_type_check()" でラップ
   します。

typing.Any

   制約のない型であることを示す特別な型。

   * 任意の型は "Any" と互換です。

   * "Any" は任意の型と互換です。

typing.NoReturn

   関数が返り値を持たないことを示す特別な型です。例えば次のように使い
   ます:

      from typing import NoReturn

      def stop() -> NoReturn:
          raise RuntimeError('no way')

   バージョン 3.6.5 で追加.

typing.Union

   ユニオン型; "Union[X, Y]" は X または Y を表します。

   ユニオン型を定義します、例えば "Union[int, str]" のように使います。
   詳細:

   * 引数は型でなければならず、少なくとも一つ必要です。

   * ユニオン型のユニオン型は平滑化されます。例えば:

        Union[Union[int, str], float] == Union[int, str, float]

   * 引数が一つのユニオン型は消えます。例えば:

        Union[int] == int  # The constructor actually returns int

   * 冗長な実引数は飛ばされます。例えば:

        Union[int, str, int] == Union[int, str]

   * ユニオン型を比較するとき引数の順序は無視されます。例えば:

        Union[int, str] == Union[str, int]

   * クラスとそのサブクラスが指定されているとき、後者は無視されます。
     例えば:

        Union[int, object] == object

   * ユニオン型のサブクラスを作成したり、インスタンスを作成することは
     出来ません。

   * "Union[X][Y]" と書くことは出来ません。

   * "Optional[X]" を "Union[X, None]" の略記として利用することが出来
     ます。

typing.Optional

   オプショナル型。

   "Optional[X]" は "Union[X, None]" と同値です。

   これがデフォルト値を持つオプション引数とは同じ概念ではないというこ
   とに注意してください。 デフォルト値を持つオプション引数はオプション
   引数であるために、型アノテーションに "Optional" 修飾子は必要ありま
   せん。 例えば次のようになります:

      def foo(arg: int = 0) -> None:
          ...

   それとは逆に、 "None" という値が許されていることが明示されている場
   合は、引数がオプションであろうとなかろうと、 "Optional" を使うのが
   好ましいです。 例えば次のようになります:

      def foo(arg: Optional[int] = None) -> None:
          ...

typing.Tuple

   タプル型; "Tuple[X, Y]" は、最初の要素の型が X で、2つ目の要素の型
   が Y であるような、2つの要素を持つタプルの型です。

   例: "Tuple[T1, T2]"  は型変数 T1 と T2 に対応する2つの要素を持つタ
   プルです。"Tuple[int, float, str]" は int と float、 string のタプ
   ルです。

   同じ型の任意の長さのタプルを指定するには ellipsis リテラルを用いま
   す。例:  "Tuple[int, ...]"。ただの "Tuple" は "Tuple[Any, ...]" と
   等価で、さらに "tuple" と等価です。.

typing.Callable

   呼び出し可能型; "Callable[[int], str]" は (int) -> str の関数です。

   添字表記は常に2つの値とともに使われなければなりません: 実引数のリス
   トと返り値の型です。 実引数のリストは型のリストか ellipsis でなけれ
   ばなりません; 返り値の型は単一の型でなければなりません。

   オプショナル引数やキーワード引数を表すための文法はありません; その
   ような関数型はコールバックの型として滅多に使われません。
   "Callable[..., ReturnType]" (リテラルの Ellipsis) は任意の個数の引
   数をとり "ReturnType" を返す型ヒントを与えるために使えます。 普通の
   "Callable" は "Callable[..., Any]" と同等で、
   "collections.abc.Callable" でも同様です。

typing.ClassVar

   クラス変数であることを示す特別な型構築子です。

   **PEP 526** で導入された通り、 ClassVar でラップされた変数アノテー
   ションによって、ある属性はクラス変数として使うつもりであり、そのク
   ラスのインスタンスから設定すべきではないということを示せます。使い
   方は次のようになります:

      class Starship:
          stats: ClassVar[Dict[str, int]] = {} # class variable
          damage: int = 10                     # instance variable

   "ClassVar" は型のみを受け入れ、それ以外は受け付けられません。

   ClassVar はクラスそのものではなく、"isinstance()" や "issubclass()"
   で使うべきではありません。 "ClassVar" は Python の実行時の挙動を変
   えませんが、サードパーティの型検査器で使えます。 例えば、型チェッカ
   ーは次のコードをエラーとするかもしれません:

      enterprise_d = Starship(3000)
      enterprise_d.stats = {} # Error, setting class variable on instance
      Starship.stats = {}     # This is OK

   バージョン 3.5.3 で追加.

typing.AnyStr

   "AnyStr" は "AnyStr = TypeVar('AnyStr', str, bytes)" として定義され
   る型変数です。

   他の種類の文字列を混ぜることなく、任意の種類の文字列を許す関数によ
   って使われることを意図しています。

      def concat(a: AnyStr, b: AnyStr) -> AnyStr:
          return a + b

      concat(u"foo", u"bar")  # Ok, output has type 'unicode'
      concat(b"foo", b"bar")  # Ok, output has type 'bytes'
      concat(u"foo", b"bar")  # Error, cannot mix unicode and bytes

typing.TYPE_CHECKING

   サードパーティーの静的型検査器が "True" と仮定する特別な定数です。
   実行時には "False" になります。使用例:

      if TYPE_CHECKING:
          import expensive_mod

      def fun(arg: 'expensive_mod.SomeType') -> None:
          local_var: expensive_mod.AnotherType = other_fun()

   1つ目の型アノテーションは引用符で囲って "前方参照 (forward
   reference)" にし、インタプリタのランタイムから "expensive_mod" への
   参照を隠さなければなりません。 ローカル変数への型アノテーションは評
   価されないので、2つ目のアノテーションは引用符で囲う必要はありません
   。

   バージョン 3.5.2 で追加.
