OOP, Inheritance, and Generic Operations (SICP-style Lab)

Predict outputs, trace dispatch (attribute lookup + data-directed tables), then implement and extend a tiny generic-operation system inspired by SICP.

0. Predict: Instance Attribute Shadows Class Attribute (CheckingAccount fee)

**Predict what will be printed** (write your prediction as a comment *before* running).

Focus question: when `withdraw` uses `self.withdrawal_fee`, will it use the class attribute or the instance attribute?

```python
class Account:
    def __init__(self, holder, balance=0):
        self.holder = holder
        self.balance = balance

    def withdraw(self, amount):
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance -= amount
        return self.balance

class CheckingAccount(Account):
    withdrawal_fee = 1

    def withdraw(self, amount):
        return super().withdraw(amount + self.withdrawal_fee)

ch = CheckingAccount('Eve', 10)
ch.withdrawal_fee = 5
ch.withdraw(3)
print(ch.balance)
```

What does it print?

class Account:
    def __init__(self, holder, balance=0):
        self.holder = holder
        self.balance = balance

    def withdraw(self, amount):
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance -= amount
        return self.balance

class CheckingAccount(Account):
    withdrawal_fee = 1

    def withdraw(self, amount):
        return super().withdraw(amount + self.withdrawal_fee)

ch = CheckingAccount('Eve', 10)

# Prediction (before running):
# I predict print(ch.balance) prints: _____

ch.withdrawal_fee = 5
ch.withdraw(3)
print(ch.balance)

Attribute lookup for `self.withdrawal_fee`: check the instance (`ch.__dict__`) first, then the class, then parents.

`ch.withdrawal_fee = 5` creates an instance attribute (it does not change `CheckingAccount.withdrawal_fee`).

So `withdraw(3)` becomes `super().withdraw(3 + 5)`.

# It prints 2.
# Mechanism: `self.withdrawal_fee` is looked up on the instance first; the instance attribute 5 shadows the class attribute 1.

1. Trace: Why adding a 'complex' method works (SICP Ex 2.77 flavor)

This is a tiny data-directed dispatch system.

`z` is tagged as `'complex'`, but inside it stores another tagged value (like `'rect'`).

**Task (trace, by hand):** When evaluating `magnitude(z)`,
1) How many times is `apply_generic` invoked?
2) What type-tag(s) does it see each time?
3) Which function does it dispatch to each time?

Then run to verify it returns `5.0`.

```python
import math

def attach_tag(tag, contents):
    return (tag, contents)

def type_tag(d):
    return d[0]

def contents(d):
    return d[1]

_op = {}

def put(op, tags, fn):
    _op[(op, tuple(tags))] = fn

def get(op, tags):
    return _op.get((op, tuple(tags)))

def apply_generic(op, x):
    fn = get(op, [type_tag(x)])
    return fn(contents(x))

def magnitude(z):
    return apply_generic('magnitude', z)

# rect package
put('magnitude', ['rect'], lambda xy: math.hypot(xy[0], xy[1]))

# complex package (wrapper delegates to inner tagged value)
put('magnitude', ['complex'], lambda inner_tagged: magnitude(inner_tagged))

z = attach_tag('complex', attach_tag('rect', (3.0, 4.0)))
print(magnitude(z))
```

import math

def attach_tag(tag, contents):
    return (tag, contents)

def type_tag(d):
    return d[0]

def contents(d):
    return d[1]

_op = {}

def put(op, tags, fn):
    _op[(op, tuple(tags))] = fn

def get(op, tags):
    return _op.get((op, tuple(tags)))

# We'll use this list to observe the call sequence.
trace_log = []

def apply_generic(op, x):
    trace_log.append((op, type_tag(x)))
    fn = get(op, [type_tag(x)])
    if fn is None:
        raise TypeError(f"no method for {op} on {type_tag(x)}")
    return fn(contents(x))

def magnitude(z):
    return apply_generic('magnitude', z)

# rect package
put('magnitude', ['rect'], lambda xy: math.hypot(xy[0], xy[1]))

# complex package (wrapper delegates to inner tagged value)
put('magnitude', ['complex'], lambda inner_tagged: magnitude(inner_tagged))

# Trace this:
z = attach_tag('complex', attach_tag('rect', (3.0, 4.0)))
ans = magnitude(z)
print(ans)
print('trace_log =', trace_log)

The `'complex'` magnitude method calls `magnitude` again on the inner tagged value.

So you should see dispatch once for `'complex'`, then again for `'rect'`.

This is the key SICP idea: installing forwarding methods for the wrapper type makes generic selectors work at the wrapper level.

Trace:
- First call: magnitude(z) -> apply_generic('magnitude', z) sees tag 'complex', dispatches to complex magnitude.
- complex magnitude receives the *inner tagged value* ('rect', (3,4)) and calls magnitude(inner).
- Second call: apply_generic('magnitude', inner) sees tag 'rect', dispatches to rect magnitude, returns 5.0.
So apply_generic is invoked 2 times, on tags: complex then rect.

2. Implement + Extend: Generic Equality equ? (SICP Ex 2.79 flavor)

You are given a tiny generic-operation table and two complex representations: `'rect'` and `'polar'`.

Your job:

**Part A (implement):** Install generic equality `equ(z1, z2)` for same-type comparisons:
- `('num','num')`
- `('rect','rect')`
- `('polar','polar')`

**Part B (extend):** Without changing `equ` itself, add *cross-type* comparisons so these also work:
- `('rect','polar')` and `('polar','rect')`

Rule: two complex numbers are equal if both their real parts and imaginary parts are close (use `math.isclose` with `abs_tol=1e-9`).

Before running, predict:
- Should `equ(z_rect, z_polar)` be `True` for the two representations of 3+4i below?

Then run the tests.

import math

# --- tagging + table ---
def attach_tag(tag, contents):
    return (tag, contents)

def type_tag(d):
    return d[0]

def contents(d):
    return d[1]

_op = {}

def put(op, tags, fn):
    _op[(op, tuple(tags))] = fn

def get(op, tags):
    return _op.get((op, tuple(tags)))

def apply_generic(op, *args):
    tags = [type_tag(a) for a in args]
    fn = get(op, tags)
    if fn is None:
        raise TypeError(f"No method for op={op} on types={tags}")
    raw = [contents(a) for a in args]
    return fn(*raw)

# --- generic selectors for complex ---
def real_part(z):
    return apply_generic('real_part', z)

def imag_part(z):
    return apply_generic('imag_part', z)

# --- install representations ---
# rect: (x, y)
put('real_part', ['rect'], lambda xy: xy[0])
put('imag_part', ['rect'], lambda xy: xy[1])

# polar: (r, a)
put('real_part', ['polar'], lambda ra: ra[0] * math.cos(ra[1]))
put('imag_part', ['polar'], lambda ra: ra[0] * math.sin(ra[1]))

# --- generic equality ---
def equ(x, y):
    return apply_generic('equ', x, y)

def install_equ_package():
    """Install equ methods into the table."""
    # Part A: same-type equality
    # Part B: cross-type equality
    # YOUR CODE HERE
    pass

install_equ_package()

# Some values
z_rect = attach_tag('rect', (3.0, 4.0))
z_polar = attach_tag('polar', (5.0, math.atan2(4.0, 3.0)))

n1 = attach_tag('num', 10)
n2 = attach_tag('num', 10)

# Prediction (before running):
# I predict equ(z_rect, z_polar) is ____

print(equ(n1, n2))
print(equ(z_rect, z_polar))

You are *installing* behavior: use `put('equ', [...], fn)`.

For rect/rect you can compare coordinates directly (or compare via real_part/imag_part).

For cross-type equality, it’s easiest to compare via the generic selectors `real_part` and `imag_part` by re-tagging inside the method (or by closing over the outer `real_part`/`imag_part`).

Use `math.isclose(a, b, abs_tol=1e-9)` for floating comparisons.

import math

# Same code as starter up to install_equ_package...

def install_equ_package():
    tol = 1e-9

    def close(a, b):
        return math.isclose(a, b, abs_tol=tol)

    # num
    put('equ', ['num', 'num'], lambda a, b: a == b)

    # rect-rect compares stored x,y
    put('equ', ['rect', 'rect'], lambda z1, z2: close(z1[0], z2[0]) and close(z1[1], z2[1]))

    # polar-polar compares via computed real/imag (angles can differ but represent same point)
    put('equ', ['polar', 'polar'],
        lambda ra1, ra2: close(ra1[0] * math.cos(ra1[1]), ra2[0] * math.cos(ra2[1]))
                        and close(ra1[0] * math.sin(ra1[1]), ra2[0] * math.sin(ra2[1])))

    # Cross-type: compare via generic selectors.
    # Note: the installed functions receive *contents*, so we must re-attach tags.
    put('equ', ['rect', 'polar'],
        lambda xy, ra: close(real_part(attach_tag('rect', xy)), real_part(attach_tag('polar', ra)))
                       and close(imag_part(attach_tag('rect', xy)), imag_part(attach_tag('polar', ra))))

    put('equ', ['polar', 'rect'],
        lambda ra, xy: close(real_part(attach_tag('polar', ra)), real_part(attach_tag('rect', xy)))
                       and close(imag_part(attach_tag('polar', ra)), imag_part(attach_tag('rect', xy))))