Cooperative Multitasking (Asynchronous) Paradigm

Initial Set Up

from typing import Generator, Optional
import itertools

def repeat(a: int):
    while True:
        yield a

Predecessor and Successor

def predecessor(a: int) -> Generator[int, None, None]:
    while a >= 0:
        a -= 1
        yield a


assert next(predecessor(1)) == 0
assert next(predecessor(10)) == 9

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


assert next(successor(0)) == 1
assert next(successor(10)) == 11

Addition

import itertools

def addition(addend_1: int, addend_2: int) -> Generator[int, None, None]:
    successor_ = successor(addend_1)    
    result = addend_1
    while True:
        for _ in range(addend_2):
            result = next(successor_)
        yield result


assert next(addition(0, 0)) == 0
assert next(addition(1, 0)) == 1
assert next(addition(0, 1)) == 1
assert next(addition(10, 10)) == 20

Multiplication

def multiplication(multiplicand: int, multiplier: int) -> Generator[int, None, None]:
    if multiplicand == 0 or multiplier == 0:
        yield from repeat(0)
        
    addition_ = addition(0, multiplier)
    result = multiplicand
    while True:
        for _ in range(multiplier):
            result = next(addition_)
        yield result


assert next(multiplication(0, 0)) == 0
assert next(multiplication(2, 0)) == 0
assert next(multiplication(0, 2)) == 0
assert next(multiplication(10, 10)) == 100

Exponentiation

def exponentiation(base: int, exponent: int) -> Generator[int, None, None]:
    if base == 0:
        yield from repeat(0)

    if exponent == 0:
        yield from repeat(1)

    multiplication_ = multiplication(base, exponent)
    result = 1
    while True:
        for _ in range(exponent):
            result = next(multiplication_)
        yield result


assert next(exponentiation(1, 0)) == 1
assert next(exponentiation(0, 1)) == 0
assert next(exponentiation(3, 3)) == 27