Procedural Paradigm

Predecessor and Successor

def predecessor(a: int) -> int:
    return a - 1


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

def successor(a: int) -> int:
    return a + 1


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

Addition

def addition(addend_1: int, addend_2: int) -> int:
    result = addend_1
    for _ in range(addend_2):
        result = successor(result)
    return result


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

Multiplication

def multiplication(multiplicand: int, multiplier: int) -> int:
    result = 0
    for _ in range(multiplier):
        result = addition(result, multiplicand)
    return result


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

Exponentiation

def exponentiation(base: int, exponent: int) -> float:
    result = 1
    for _ in range(exponent):
        result = multiplication(result, base)
    return result


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