monad_buildr.py

from __future__ import annotations

from typing import List, Iterable, Callable


class Wheel:
    """
    it takes a wheel to build a car.
    """
    brand: str
    speed: float

    def __init__(self, brand: str) -> None:
        self.speed = 0
        self.brand = brand

    def run(self, speed: float) -> Wheel:
        self.speed = speed
        print(f'{self.brand} wheel is running in {speed}.\n')
        return self

    def brake(self) -> Wheel:
        self.speed = 0
        print(f'{self.brand} wheel is now stopped.\n')
        return self


class Engine:
    """
    all you need is a strong heart.
    """
    max_speed: float
    speed: float

    def __init__(self, max_speed: float) -> None:
        self.speed = 0
        self.max_speed = max_speed

    def run(self, speed: float) -> Engine:
        self.speed = speed if speed <= self.max_speed else self.max_speed
        print(f'engine started, at speed {self.speed}')
        return self

    def brake(self) -> Engine:
        self.speed = 0
        print(f'engine stopped')
        return self


class Car:
    """
    it takes a tough man to build a tender car.
    """
    wheels: List[Wheel]
    engine: Engine

    def __init__(self) -> None:
        print('a brand new car!')

    def run(self, speed: float) -> Car:
        self.engine = self.engine.run(speed)
        self.wheels = [wheel.run(self.engine.speed) for wheel in self.wheels]
        return self

    def brake(self) -> Car:
        self.engine = self.engine.brake()
        self.wheels = [wheel.brake() for wheel in self.wheels]
        return self


def assemble_wheel(brand: str) -> Wheel:
    return Wheel(brand)


def assemble_engine(max_speed: float) -> Engine:
    return Engine(max_speed)


def car_builder(engine_limit: float, wheel_brand: str, wheel_num: int = 4) -> Callable[[], Car]:

    def build_wheels(car: Car) -> Iterable[Car]:
        car.wheels = [assemble_wheel(wheel_brand) for _ in range(wheel_num)]
        print(f'assemble wheels for the car')
        yield car

    def build_engine(car: Car) -> Iterable[Car]:
        car.engine = assemble_engine(engine_limit)
        print(f'assemble engine for the car')
        yield car

    def build_skeleton(car: Car) -> Iterable[Car]:
        print(f'no skeleton for car now, we are building a phantom car!')
        yield car

    def build() -> Car:
        _car = Car()
        return next(
            car
            for car in build_wheels(_car)
            for car in build_engine(car)
            for car in build_skeleton(car)
        )
    return build


if __name__ == "__main__":
    builder = car_builder(1000, '米其林', 6)
    fleet: List[Car] = [
        builder()
        for _ in range(3)
    ]
    fleet = [car.run(100) for car in fleet]
    fleet = [car.brake() for car in fleet]