Object Oriented Paradigm

Initial Set-Up

from dataclasses import dataclass
from abc import ABC, abstractmethod


class Operation(ABC):
    @abstractmethod
    def compute(self) -> float:
        ...

Predecessor and Successor

@dataclass
class Predecessor(Operation):
    a: int

    def compute(self) -> int:
        return self.a - 1


assert Predecessor(1).compute() == 0
assert Predecessor(10).compute() == 9

@dataclass
class Successor(Operation):
    a: int

    def compute(self) -> int:
        return self.a + 1


assert Successor(0).compute() == 1
assert Successor(10).compute() == 11

Addition

@dataclass
class Adder(Operation):
    addend_1: int
    addend_2: int

    def compute(self) -> int:
        result = self.addend_1
        for _ in range(self.addend_2):
            result = Successor(result).compute()
        return result


assert Adder(0, 0).compute() == 0
assert Adder(1, 0).compute() == 1
assert Adder(0, 1).compute() == 1
assert Adder(10, 10).compute() == 20

Multiplication

@dataclass
class Multiplier(Operation):
    multiplier: int
    multiplicand: int

    def compute(self) -> int:
        result = 0
        for _ in range(self.multiplier):
            result = Adder(result, self.multiplicand).compute()
        return result


assert Multiplier(0, 0).compute() == 0
assert Multiplier(2, 0).compute() == 0
assert Multiplier(0, 2).compute() == 0
assert Multiplier(10, 10).compute() == 100

Exponentiation

@dataclass
class Power(Operation):
    base: int
    exponent: int

    def compute(self) -> int:
        result = 1
        for _ in range(self.exponent):
            result = Multiplier(result, self.base).compute()
        return result


assert Power(1, 0).compute() == 1
assert Power(0, 1).compute() == 0
assert Power(3, 3).compute() == 27