ch15: draft examples

Author: ramalho

15-more-types/cafeteria/cafeteria.py

@@ -0,0 +1,41 @@
+from typing import TypeVar, Generic
+
+
+class Beverage:
+    """Any beverage"""
+
+
+class Juice(Beverage):
+    """Any fruit juice"""
+
+
+class OrangeJuice(Juice):
+    """Delicious juice Brazilian oranges"""
+
+
+class Coak(Beverage):
+    """Secret formula with lots of sugar"""
+
+
+BeverageT = TypeVar('BeverageT', bound=Beverage)
+JuiceT = TypeVar('JuiceT', bound=Juice)
+
+
+class BeverageDispenser(Generic[BeverageT]):
+
+    beverage: BeverageT
+
+    def __init__(self, beverage: BeverageT) -> None:
+        self.beverage = beverage
+
+    def dispense(self) -> BeverageT:
+        return self.beverage
+
+
+class JuiceDispenser(BeverageDispenser[JuiceT]):
+    pass
+
+
+class Cafeteria:
+    def __init__(self, dispenser: BeverageDispenser[JuiceT]):
+        self.dispenser = dispenser

15-more-types/cafeteria/cafeteria_demo.py

@@ -0,0 +1,23 @@
+from cafeteria import (
+    Cafeteria,
+    BeverageDispenser,
+    JuiceDispenser,
+    Juice,
+    OrangeJuice,
+    Coak,
+)
+
+orange = OrangeJuice()
+
+orange_dispenser: JuiceDispenser[OrangeJuice] = JuiceDispenser(orange)
+
+juice: Juice = orange_dispenser.dispense()
+
+soda = Coak()
+
+## Value of type variable "JuiceT" of "JuiceDispenser" cannot be "Coak"
+# soda_dispenser = JuiceDispenser(soda)
+
+soda_dispenser = BeverageDispenser(soda)
+
+arnold_hall = Cafeteria(soda_dispenser)

15-more-types/collections_variance.py

@@ -0,0 +1,16 @@
+from collections.abc import Collection, Sequence
+
+col_int: Collection[int]
+
+seq_int: Sequence[int] = (1, 2, 3)
+
+## Incompatible types in assignment
+##   expression has type "Collection[int]"
+##     variable has type "Sequence[int]"
+# seq_int = col_int
+
+col_int = seq_int
+
+## List item 0 has incompatible type "float"
+##   expected "int"
+# col_int = [1.1]

15-type-hints/erp.py 15-more-types/erp.py15-type-hints/erp.py renamed to 15-more-types/erp.py

@@ -1,5 +1,4 @@
-import random
-from typing import Iterable, TYPE_CHECKING, List
+from typing import TYPE_CHECKING
 
 from erp import EnterpriserRandomPopper
 import randompop
@@ -9,7 +8,6 @@ def test_issubclass() -> None:
     assert issubclass(EnterpriserRandomPopper, randompop.RandomPopper)
 
 
-
 def test_isinstance_untyped_items_argument() -> None:
     items = [1, 2, 3]
     popper = EnterpriserRandomPopper(items)  # [int] is not required

15-type-hints/erp_test.py 15-more-types/erp_test.py15-type-hints/erp_test.py renamed to 15-more-types/erp_test.py

@@ -0,0 +1,59 @@
+"""
+In ``Generator[YieldType, SendType, ReturnType]``,
+``SendType`` is contravariant.
+The other type variables are covariant.
+
+This is how ``typing.Generator`` is declared::
+
+    class Generator(Iterator[T_co], Generic[T_co, T_contra, V_co]):
+
+(from https://docs.python.org/3/library/typing.html#typing.Generator)
+
+"""
+
+from typing import Generator
+
+
+# Generator[YieldType, SendType, ReturnType]
+
+def gen_float_take_int() -> Generator[float, int, str]:
+    received = yield -1.0
+    while received:
+        received = yield float(received)
+    return 'Done'
+
+
+def gen_float_take_float() -> Generator[float, float, str]:
+    received = yield -1.0
+    while received:
+        received = yield float(received)
+    return 'Done'
+
+
+def gen_float_take_complex() -> Generator[float, complex, str]:
+    received = yield -1.0
+    while received:
+        received = yield abs(received)
+    return 'Done'
+
+# Generator[YieldType, SendType, ReturnType]
+
+g0: Generator[float, float, str] = gen_float_take_float()
+
+g1: Generator[complex, float, str] = gen_float_take_float()
+
+## Incompatible types in assignment
+##   expression has type "Generator[float, float, str]"
+##     variable has type "Generator[int, float, str]")
+# g2: Generator[int, float, str] = gen_float_take_float()
+
+
+# Generator[YieldType, SendType, ReturnType]
+
+g3: Generator[float, int, str] = gen_float_take_float()
+
+## Incompatible types in assignment
+##   expression has type "Generator[float, float, str]"
+##     variable has type "Generator[float, complex, str]")
+## g4: Generator[float, complex, str] = gen_float_take_float()
+

15-more-types/gen_contra.py

@@ -0,0 +1,47 @@
+from typing import TypeVar, Generic, Any
+
+
+class Pet:
+    """Domestic animal kept for companionship."""
+
+
+class Dog(Pet):
+    """Canis familiaris"""
+
+
+class Cat(Pet):
+    """Felis catus"""
+
+
+class Siamese(Cat):
+    """Cat breed from Thailand"""
+
+
+T = TypeVar('T')
+
+
+class Box(Generic[T]):
+    def put(self, item: T) -> None:
+        self.contents = item
+
+    def get(self) -> T:
+        return self.contents
+
+
+T_contra = TypeVar('T_contra', contravariant=True)
+
+
+class InBox(Generic[T_contra]):
+    def put(self, item: T) -> None:
+        self.contents = item
+
+
+T_co = TypeVar('T_co', covariant=True)
+
+
+class OutBox(Generic[T_co]):
+    def __init__(self, contents: Any):
+        self.contents = contents
+
+    def get(self) -> Any:
+        return self.contents

15-more-types/petbox/petbox.py

@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING
+
+from petbox import *
+
+
+cat_box: Box[Cat] = Box()
+
+si = Siamese()
+
+cat_box.put(si)
+
+animal = cat_box.get()
+
+#if TYPE_CHECKING:
+#    reveal_type(animal)  # Revealed: petbox.Cat*
+
+
+################### Covariance
+
+out_box: OutBox[Cat] = OutBox(Cat())
+
+out_box_si: OutBox[Siamese] = OutBox(Siamese())
+
+## Incompatible types in assignment
+##   expression has type "OutBox[Cat]"
+#      variable has type "OutBox[Siamese]"
+# out_box_si = out_box
+
+out_box = out_box_si
+
+################### Contravariance
+
+in_box: InBox[Cat] = InBox()
+
+in_box_si: InBox[Siamese] = InBox()
+
+in_box_si = in_box
+
+## Incompatible types in assignment
+##   expression has type "InBox[Siamese]"
+##     variable has type "InBox[Cat]"
+# in_box = in_box_si

15-more-types/petbox/petbox_demo.py

@@ -4,7 +4,7 @@
 from randompick_generic import GenericRandomPicker
 
 
-class LottoPicker():
+class LottoPicker:
     def __init__(self, items: Iterable[int]) -> None:
         self._items = list(items)
         random.shuffle(self._items)