Mutable Data Lab

Practice reasoning about time-varying state: mutation vs rebinding, closures with nonlocal state, aliasing, identity vs equality, and the mutable-default-argument trap.

0. Predict: The Mutable Default Trap

**Predict the result** before running.

This function has a mutable default argument:

```python
def append_bad(item, bucket=[]):
    bucket.append(item)
    return bucket

def demo():
    a = append_bad(1)
    b = append_bad(2)
    fresh = append_bad(3, [])
    return a, b, (a is b), fresh
```

1) What does `demo()` return?
2) Why is `(a is b)` either `True` or `False`?

After you write your prediction, run the code to check.

def append_bad(item, bucket=[]):
    bucket.append(item)
    return bucket

def demo():
    a = append_bad(1)
    b = append_bad(2)
    fresh = append_bad(3, [])
    return a, b, (a is b), fresh

# Prediction (write before running):
# I predict demo() returns: ???

# Uncomment to check:
# print(demo())

Default argument expressions are evaluated once, at function definition time.

`bucket.append(...)` mutates the *existing list object* in place.

`is` checks whether two names refer to the same object (identity), not whether they have equal contents.

def append_bad(item, bucket=[]):
    bucket.append(item)
    return bucket

def demo():
    a = append_bad(1)
    b = append_bad(2)
    fresh = append_bad(3, [])
    return a, b, (a is b), fresh

1. Trace: Where Does the Balance Live?

This closure uses `nonlocal` to update a private `balance` over time.

```python
def make_withdraw(balance):
    def withdraw(amount):
        nonlocal balance
        if amount <= balance:
            balance -= amount
            return balance
        return "Insufficient funds"
    return withdraw
```

**Trace** `run()` by writing (in comments) what `balance` is after each call, and what each call returns.

Focus questions:
- Which frame stores `balance`?
- Does a failed withdrawal change `balance`?

Then run to confirm.

def make_withdraw(balance):
    def withdraw(amount):
        nonlocal balance
        if amount <= balance:
            balance -= amount
            return balance
        return "Insufficient funds"
    return withdraw

def run():
    wd = make_withdraw(100)
    # Trace in comments (before running):
    # Call 1: wd(25) returns ___, balance becomes ___
    # Call 2: wd(25) returns ___, balance becomes ___
    # Call 3: wd(60) returns ___, balance becomes ___
    # Call 4: wd(15) returns ___, balance becomes ___
    return [wd(25), wd(25), wd(60), wd(15)]

# Uncomment to check:
# print(run())

`withdraw` is a closure: it carries a reference to the frame created by `make_withdraw`.

`nonlocal balance` means rebinding the name `balance` in the enclosing frame (not creating a new local variable).

If the function returns "Insufficient funds", it should not subtract anything.

def make_withdraw(balance):
    def withdraw(amount):
        nonlocal balance
        if amount <= balance:
            balance -= amount
            return balance
        return "Insufficient funds"
    return withdraw

def run():
    wd = make_withdraw(100)
    return [wd(25), wd(25), wd(60), wd(15)]

2. Extend: Password-Protected Account (SICP Ex 3.3)

Modify message-passing bank accounts to require a password.

Implement `make_account(balance, password)` so that:
- `acc(correct_pw, "withdraw")` returns a **function** that withdraws.
- `acc(correct_pw, "deposit")` returns a **function** that deposits.
- Any request with a wrong password returns the string **"Incorrect password"** (not a function).

**Predict (before running)** what each line should evaluate to:

```python
acc = make_account(100, "secret")
acc("secret", "deposit")(50)      # ?
acc("secret", "withdraw")(30)    # ?
acc("wrong", "withdraw")         # ?
```

Then implement and run the tests.

def make_account(balance, password):
    """Return a password-protected dispatch function.

    acc(pw, msg) returns either a function (withdraw/deposit) or the string
    "Incorrect password".
    """
    # YOUR CODE HERE
    pass

# Prediction (write before running):
# acc = make_account(100, "secret")
# acc("secret", "deposit")(50) => ???
# acc("secret", "withdraw")(30) => ???
# acc("wrong", "withdraw") => ???

Use `nonlocal balance` inside `withdraw` and `deposit` to update the enclosed state.

`dispatch` should check the password *before* choosing which operation to return.

Return a function for valid requests; return a string for invalid password.

def make_account(balance, password):
    def withdraw(amount):
        nonlocal balance
        if amount <= balance:
            balance -= amount
            return balance
        return "Insufficient funds"

    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance

    def dispatch(pw, message):
        if pw != password:
            return "Incorrect password"
        if message == "withdraw":
            return withdraw
        if message == "deposit":
            return deposit
        raise ValueError(f"Unknown request: {message}")

    return dispatch