Python Walrus Operator — List Comprehension Variable Leak

# io/thecodeforge/walrus_basics.py
# ------------------------------------------------------------
# The fundamental distinction: statement vs expression
# ------------------------------------------------------------

# Regular assignment (=) is a STATEMENT — standalone only.
# This is a SyntaxError — you cannot use = inside a condition:
# if user_input = input('Enter a command: '):  # SyntaxError

# The traditional workaround: assign first, then check.
user_input = input('Enter a command: ')
if user_input:
    print(f'Traditional approach — you typed: {user_input}')

print('---')

# Walrus operator (:=) is an EXPRESSION — it assigns AND returns the value.
# The value from input() is bound to 'command' AND tested for truthiness
# in a single expression — no separate assignment line needed.
if command := input('Enter a command: '):
    print(f'Walrus approach — you typed: {command}')

print('---')

# Demonstrating that := returns the assigned value.
# This is the mechanism that makes everything else possible.
sample_list = [1, 2, 3, 4, 5]

# last_item is assigned AND the truthiness check happens simultaneously.
if last_item := sample_list[-1]:
    print(f'Last item is: {last_item}')  # prints 5

# You can observe the return value directly.
numbers = [10, 20, 30]
# print() receives the return value of :=, which is 60.
# AND total is bound to 60 for use after this line.
print(total := sum(numbers))           # prints: 60
print(f'total persists after: {total}')  # prints: total persists after: 60

# ------------------------------------------------------------
# Where := is NOT allowed — important parser restrictions
# ------------------------------------------------------------

# 1. Cannot use := at the top level of an expression statement
#    (use regular = for simple assignments — that's what it's for).
# y := 5  # SyntaxError — use y = 5

# 2. Cannot use := in a lambda body — PEP 572 grammar rule, all contexts.
# f = lambda x: (y := x + 1)  # SyntaxError

# 3. Cannot use := without parentheses alongside comparison operators —
#    := has lower precedence than >, <, ==, so without parens:
#    result := compute() > 0  parses as  result := (compute() > 0)
#    which binds a boolean, not the compute() return value.
# if result := compute() > 0:    # binds bool — almost certainly wrong
# if (result := compute()) > 0:  # correct — parens make intent explicit

print('\nBasics complete — := assigns AND returns the value.')

# io/thecodeforge/walrus_scope_rules.py
# ============================================================
# SCOPE RULE 1: Walrus variables LEAK to the enclosing scope.
# Regular iteration variables do NOT.
# ============================================================

temperature_readings = [18.5, 23.1, 35.7, 29.4, 41.2, 15.0]
heat_threshold = 30.0

hot_readings = [
    captured
    for reading in temperature_readings
    if (captured := reading) >= heat_threshold  # 35.7 and 41.2 pass
]
print(f'Hot readings: {hot_readings}')  # [35.7, 41.2]

# CRITICAL: 'captured' is now accessible outside the comprehension.
# It holds 15.0 — the LAST value assigned by :=, which is the last
# item processed (15.0), NOT the last value that passed the filter (41.2).
# This distinction causes real production bugs when the leaked variable
# is used downstream under the assumption it holds the last passing value.
print(f'captured after comprehension: {captured}')  # 15.0, NOT 41.2

# 'reading' by contrast does NOT exist outside the comprehension.
# print(reading)  # NameError: name 'reading' is not defined

print()

# ============================================================
# SCOPE RULE 2: Walrus leaks to the ENCLOSING FUNCTION scope,
# not to module level when inside a function.
# ============================================================

captured = 'module_level_value'  # module-level name

def process_readings(data: list[float]) -> list[float]:
    # The walrus inside this comprehension leaks to this function's scope,
    # not to module scope. The module-level 'captured' above is unaffected.
    above_threshold = [
        val
        for item in data
        if (val := item * 1.1) > 25.0
    ]
    # 'val' is now accessible here inside process_readings.
    print(f'  Last val assigned inside function: {val}')
    return above_threshold

result = process_readings([10.0, 20.0, 25.0, 30.0])
print(f'Module-level captured is unchanged: {captured}')  # still 'module_level_value'
print(f'Processed result: {result}')

print()

# ============================================================
# SCOPE RULE 3: The precedence trap — always use parentheses.
# This is the category of bug that takes 45 minutes to find on-call.
# ============================================================

import math

def compute_score(x: float) -> float:
    return round(math.sqrt(x) * 100, 2)

values = [3, 7, 12, 2, 9]

# WRONG: without parentheses, := binds the boolean result of
# (compute_score(v) > 15). 'score' will be True or False,
# not the float from compute_score. No SyntaxError. Silent wrong result.
wrong_results = [
    score
    for v in values
    if (score := compute_score(v) > 15)  # parsed as: score := (compute_score(v) > 15)
]
print(f'Wrong — score is boolean: {wrong_results}')  # [True, True]

# CORRECT: parentheses around the full := expression.
# Now compute_score(v) is called, the result is bound to score,
# and THEN the > 15 comparison happens on the bound float.
correct_results = [
    score
    for v in values
    if (score := compute_score(v)) > 15  # parsed as: (score := compute_score(v)) > 15
]
print(f'Correct — score is float: {correct_results}')  # [17.5, 30.0, 22.5]

print()

# ============================================================
# ILLEGAL: You cannot rebind the comprehension's loop variable.
# ============================================================
# Uncomment to see the SyntaxError:
# bad = [reading := reading * 2 for reading in temperature_readings]
# SyntaxError: assignment expression cannot rebind comprehension iteration variable

# ============================================================
# SCOPE RULE 4: Generator expression — walrus assigns LAZILY.
# The variable does not exist until the generator is consumed.
# ============================================================

def slow_transform(x: float) -> float:
    return x * 1.5

data_stream = [10.0, 5.0, 20.0, 3.0]

# List comprehension: all walrus assignments happen immediately.
list_comp = [r for x in data_stream if (r := slow_transform(x)) > 10.0]
print(f'After list comprehension, r = {r}')  # r exists, holds last assigned value

# Generator expression: walrus assignments happen lazily.
gen_expr = (r for x in data_stream if (r := slow_transform(x)) > 10.0)
# At this point, r still holds the value from the list comprehension above!
# The generator has not been consumed yet — no new := has executed.
print(f'After defining generator (not consumed), r = {r}')  # stale value from above

first_result = next(gen_expr)  # consume one item — NOW the first := executes
print(f'After first next(), r = {r}')  # updated to first passing value

print()

# ============================================================
# SCOPE RULE 5: Nested comprehensions leak to function scope —
# not just to the outer comprehension level.
# ============================================================

def nested_example(matrix: list[list[int]]) -> list[int]:
    flat_above_threshold = [
        cell
        for row in matrix
        for cell in row
        if (cell_val := cell) > 5
    ]
    # cell_val is accessible here at the function level.
    # Not just inside the comprehension, not just at the outer loop level.
    print(f'  Last cell_val at function scope: {cell_val}')
    return flat_above_threshold

grid = [[1, 6, 3], [8, 2, 7], [4, 9, 5]]
print(f'Cells above 5: {nested_example(grid)}')

print('\nScope rules complete.')

# io/thecodeforge/walrus_four_patterns.py
import re
import math
import time
import timeit

# ============================================================
# PATTERN 1: While-loop stream reading
# Replaces the classic 'while True: ... break' sentinel pattern.
# Also demonstrates while/else for clean stream exhaustion handling.
# ============================================================

data_chunks = [b'payload_one', b'payload_two', b'payload_three', b'', b'ignored']
chunk_index = 0

def read_next_chunk() -> bytes:
    """Simulates reading from a socket or file — returns b'' when exhausted."""
    global chunk_index
    if chunk_index < len(data_chunks):
        chunk = data_chunks[chunk_index]
        chunk_index += 1
        return chunk
    return b''

print('=== Pattern 1: Stream Reading with while/else ===')

# The classic sentinel pattern before walrus — two read calls or a sentinel var:
# while True:
#     chunk = read_next_chunk()
#     if not chunk:
#         break
#     process(chunk)

# With walrus: assign the read result AND test it in one expression.
# while/else gives a clean finalisation hook when the stream exhausts.
while received_chunk := read_next_chunk():
    print(f'  Processing: {received_chunk.decode()}')
else:
    # This block runs when the while condition becomes falsy —
    # i.e., when read_next_chunk() returns b''. Clean stream exhaustion.
    print('  Stream exhausted cleanly — else block executed.')

print()

# ============================================================
# PATTERN 2: Comprehension filter with result reuse
# Benchmark demonstrates the call-count halving on passing items.
# ============================================================

call_counter = {'without_walrus': 0, 'with_walrus': 0}

def expensive_transform_no_walrus(value: float) -> float:
    """
    Simulates a CPU-heavy operation with 1ms latency.
    Counts calls to prove the double-call problem.
    """
    call_counter['without_walrus'] += 1
    time.sleep(0.001)  # 1ms simulated latency
    return round(math.sqrt(value) * 100, 2)

def expensive_transform_walrus(value: float) -> float:
    """Same operation — separate counter to isolate the measurement."""
    call_counter['with_walrus'] += 1
    time.sleep(0.001)
    return round(math.sqrt(value) * 100, 2)

raw_scores = [4, 9, 1, 16, 25, 0, 36]  # 5 pass threshold 150.0, 2 fail
threshold = 150.0

print('=== Pattern 2: Comprehension Filter — Call Count Comparison ===')

# WITHOUT walrus: expensive_transform is called TWICE for every item
# that passes the filter — once in the if clause, once in the output.
results_without = [
    expensive_transform_no_walrus(score)
    for score in raw_scores
    if expensive_transform_no_walrus(score) >= threshold
]

# WITH walrus: exactly one call per item regardless of filter outcome.
results_with = [
    transformed
    for score in raw_scores
    if (transformed := expensive_transform_walrus(score)) >= threshold
]

print(f'  Results match: {results_without == results_with}')  # True
print(f'  Without walrus — total calls: {call_counter["without_walrus"]}')  # 12
print(f'  With walrus    — total calls: {call_counter["with_walrus"]}')    # 7
print(f'  Items in list: {len(raw_scores)}, items passing filter: {len(results_with)}')
print(f'  Call overhead eliminated: {call_counter["without_walrus"] - call_counter["with_walrus"]}')
# 7 items * 1 call each = 7 total with walrus
# 2 items fail (1 call each) + 5 items pass (2 calls each) = 2 + 10 = 12 without walrus
# Difference: 5 redundant calls eliminated — one per passing item.

print()

# ============================================================
# PATTERN 3: Regex match in a conditional
# One walrus per condition — if you need two groups, write two lines.
# ============================================================

log_lines = [
    '2026-01-15 ERROR: Disk quota exceeded for user admin',
    '2026-01-15 INFO: Backup completed successfully',
    '2026-01-16 ERROR: Connection timeout on port 5432',
    '2026-01-16 DEBUG: Cache warmed in 42ms',
]

error_pattern = re.compile(r'(\d{4}-\d{2}-\d{2}) ERROR: (.+)')

print('=== Pattern 3: Regex Match in Conditional ===')

# WITHOUT walrus: two lines before we can use the match object.
# for line in log_lines:
#     match_result = error_pattern.search(line)
#     if match_result:
#         date, msg = match_result.groups()

# WITH walrus: match and None-check happen simultaneously.
# If search() returns None, the condition is falsy and the body is skipped.
# If it returns a match object (truthy), it's bound and ready to use.
for log_line in log_lines:
    if match_result := error_pattern.search(log_line):
        error_date, error_message = match_result.groups()
        print(f'  [ALERT] {error_date} — {error_message}')

print()

# ============================================================
# PATTERN 4: any()/all() with early exit and result capture
# Short-circuit evaluation + result capture in one expression.
# If any() returns False, grant_record holds the last assigned value.
# ============================================================

def check_permission(user_id: str, resource: str) -> dict | None:
    """
    Simulates an expensive permission check — e.g., an LDAP lookup or
    a policy engine evaluation. Returns a permission record or None.
    """
    permissions = {
        ('user_42', 'billing'): {'level': 'read', 'granted_by': 'admin_role'},
        ('user_99', 'reports'): {'level': 'write', 'granted_by': 'direct_grant'},
    }
    return permissions.get((user_id, resource))

resources_to_check = ['dashboard', 'billing', 'reports', 'admin_panel']
current_user = 'user_42'

print('=== Pattern 4: any() with Early Exit and Result Capture ===')

# WITHOUT walrus: either iterate twice or write an explicit for/break loop.
grant_record = None
for resource in resources_to_check:
    record = check_permission(current_user, resource)
    if record:
        grant_record = record
        break
if grant_record:
    print(f'  Without walrus — first access found: {grant_record}')

# WITH walrus: any() short-circuits on the first truthy result.
# The walrus binding captures that result at the moment any() finds it.
# check_permission() is never called again — we have the result already.
if any((grant_record := check_permission(current_user, r)) for r in resources_to_check):
    print(f'  With walrus — first access found: {grant_record}')

# Demonstrate the False case — what grant_record holds when no permission exists.
no_access_user = 'user_00'
if any((no_grant := check_permission(no_access_user, r)) for r in resources_to_check):
    print(f'  Should not print')
else:
    # no_grant holds the last value assigned — None in this case,
    # because check_permission returns None for all resources for user_00.
    # Always check the any() result before using the walrus variable.
    print(f'  No permission found. no_grant holds last assigned value: {no_grant}')

# io/thecodeforge/walrus_do_and_dont.py
import hashlib

def hash_value(raw: str) -> str:
    """Simulates an expensive hashing operation."""
    return hashlib.sha256(raw.encode()).hexdigest()

def validate_strength(password: str) -> bool:
    """Cheap check — length and digit requirement."""
    return len(password) >= 8 and any(c.isdigit() for c in password)

def fetch_user_profile(user_id: str) -> dict | None:
    """Simulates a database call — 50-100ms in production."""
    profiles = {
        'u1': {'name': 'Alice', 'active': True, 'role': 'admin'},
        'u2': {'name': 'Bob', 'active': False, 'role': 'viewer'},
    }
    return profiles.get(user_id)

def build_display_record(profile: dict) -> dict | None:
    """Simulates a transformation — another meaningful computation."""
    if not profile or not profile.get('active'):
        return None
    return {'display_name': profile['name'].upper(), 'role': profile['role']}

# ============================================================
# GOOD: Walrus genuinely prevents a double expensive call.
# validate_strength is cheap — run it first to avoid hash calls
# on weak passwords. hash_value is expensive — called exactly once
# per candidate that passes the strength filter.
# ============================================================

password_candidates = ['weak', 'Str0ngPass', 'bad', 'S3cureKey', '1234abcd']

print('=== GOOD: Single hash computation per passing candidate ===')
valid_hashes = [
    computed_hash
    for candidate in password_candidates
    if validate_strength(candidate)                          # cheap filter first
    and (computed_hash := hash_value(candidate))            # expensive — exactly once
]
for h in valid_hashes:
    print(f'  Hash prefix: {h[:16]}...')

print()

# ============================================================
# BAD: Walrus with a trivially cheap operation.
# The alternative is one plain line. Use it.
# ============================================================

print('=== BAD: Walrus adds noise where plain assignment is clearer ===')

# This works but signals to every reader that something meaningful
# is being captured for reuse — when it isn't. Misleading intent.
if (count := len(password_candidates)) > 0:
    print(f'  Walrus version: processing {count} candidates')

# This is correct — same result, zero mental overhead.
count = len(password_candidates)
if count > 0:
    print(f'  Plain version: processing {count} candidates')

print()

# ============================================================
# REALISTIC MISUSE: Chained walrus in a single condition.
# This is what actually appears in code reviews — looks reasonable,
# is genuinely hard to debug when either step returns falsy.
# ============================================================

print('=== REALISTIC MISUSE: Chained walrus — ambiguous failure point ===')

user_ids = ['u1', 'u2', 'u3']

for uid in user_ids:
    # When this condition fails, which step caused it?
    # profile could be None (fetch failed) OR build_display_record returned None
    # (user inactive). You have two variables to check to find out.
    # During an on-call incident, that ambiguity costs minutes you don't have.
    if (profile := fetch_user_profile(uid)) and (record := build_display_record(profile)):
        print(f'  Chained walrus: {record}')
    else:
        failed_at = 'fetch' if not profile else 'build'
        print(f'  Chained walrus: skipped uid={uid}, failed at: {failed_at}')

print()

# The explicit version — each failure point is immediately obvious.
# This is what you want at 2 AM during an incident.
for uid in user_ids:
    profile = fetch_user_profile(uid)
    if not profile:
        print(f'  Explicit: no profile for uid={uid}')
        continue
    record = build_display_record(profile)
    if not record:
        print(f'  Explicit: inactive user uid={uid}')
        continue
    print(f'  Explicit: {record}')

print()

# ============================================================
# NEVER: Multiple walrus operators in a single expression.
# Syntactically valid. Never acceptable in a reviewed codebase.
# ============================================================

print('=== NEVER: Multi-walrus one-liner ===')
text = 'Python3walrus'

# Valid Python. Fails the three-second readability test decisively.
if (n := len(text)) > 5 and (u := text.upper()) and (p := u.startswith('P')):
    print(f'  Multi-walrus: length={n}, upper={u}, startsWithP={p}')

# Write this instead — every variable is named, every step is visible.
n = len(text)
u = text.upper()
p = u.startswith('P')
if n > 5 and u and p:
    print(f'  Explicit: length={n}, upper={u}, startsWithP={p}')

# io/thecodeforge/walrus_pipeline_bug.py
# Demonstrates the scope leak collision pattern that caused the
# production incident described above.

from typing import Any

def has_sufficient_features(record: dict) -> bool:
    """Cheap check — returns True if the record has enough data to score."""
    return len(record.get('features', [])) >= 3

def score_record(record: dict) -> float:
    """Simulates expensive ML inference — returns a confidence score 0.0-1.0."""
    # Deterministic fake scores based on record ID for reproducibility.
    fake_scores = {'r1': 0.92, 'r2': 0.45, 'r3': 0.88, 'r4': 0.31, 'r5': 0.67}
    return fake_scores.get(record['id'], 0.0)

def route_to_queue(record: dict, confidence: float) -> None:
    """Simulates sending a record to the downstream routing queue."""
    print(f'  Routing {record["id"]} with confidence {confidence:.2f}')

batch = [
    {'id': 'r1', 'features': [1.0, 2.0, 3.0, 4.0]},
    {'id': 'r2', 'features': [1.0]},            # fails feature check
    {'id': 'r3', 'features': [1.0, 2.0, 3.0]},
    {'id': 'r4', 'features': [1.0, 2.0, 3.0]},
    {'id': 'r5', 'features': [1.0, 2.0, 3.0, 4.0]},  # last in batch — score 0.67
]
routing_threshold = 0.80

print('=== BROKEN: Walrus variable name collision across two comprehensions ===')

# Stage 1: filter records with sufficient features.
# Walrus assigns to 'score' — but this isn't a score, it's a boolean.
# The developer used 'score' because they planned to use it in stage 2.
# This is already wrong conceptually, but it doesn't fail here.
filterable_records = [
    record
    for record in batch
    if (score := has_sufficient_features(record))  # 'score' is True or False here
]
print(f'  After stage 1, score = {score}')  # True or False — last item in batch

# Stage 2: score the filtered records.
# A second := using the same name 'score' overwrites whatever stage 1 left.
high_confidence_records = [
    record
    for record in filterable_records
    if (score := score_record(record)) >= routing_threshold
]
# After stage 2, 'score' holds the last value assigned by score_record(),
# which is 0.67 (r5, last in filterable_records) — below routing_threshold.
# 0.67 is falsy as a float? No — 0.67 is truthy. But what if it were 0.0?
# The bug is that 'score' no longer reliably represents anything useful.
print(f'  After stage 2, score = {score}')  # 0.67 — last computed, not last passing
print(f'  High confidence records: {[r["id"] for r in high_confidence_records]}')

# The downstream routing code — the bug lives here.
# In the original incident, this was in a separate function that received
# 'score' from the outer scope. When score held 0.0, this silently skipped all routing.
if score:  # 0.67 is truthy — but this check is checking the WRONG thing
    for record in high_confidence_records:
        route_to_queue(record, score)  # routes with 0.67 — wrong confidence value!
        # r1 and r3 should route with 0.92 and 0.88 respectively, not 0.67

print()
print('=== FIXED: Distinct walrus names, routing uses captured confidence ===')

# Stage 1: 'has_features' makes the boolean nature of the binding explicit.
filterable_records_fixed = [
    record
    for record in batch
    if (has_features := has_sufficient_features(record))
]

# Stage 2: 'confidence_score' is unambiguous — it cannot be confused with
# the boolean from stage 1, and its name signals exactly what it holds.
high_confidence_fixed = [
    (record, confidence_score)  # capture (record, score) pair — no leaked variable needed
    for record in filterable_records_fixed
    if (confidence_score := score_record(record)) >= routing_threshold
]

# Routing uses the captured pair — no dependency on leaked scope variable.
for record, captured_confidence in high_confidence_fixed:
    route_to_queue(record, captured_confidence)  # correct confidence per record

print()
print(f'  confidence_score after stage 2: {confidence_score}')  # 0.88 (r3, last passing)
print('  But we are NOT using confidence_score for routing — the pair carries the value.')

# io/thecodeforge/walrus_match_case.py
# Python 3.10+ — structural pattern matching + walrus operator

from dataclasses import dataclass
import hashlib

@dataclass
class APIRequest:
    method: str
    path: str
    body: dict
    auth_token: str

def validate_auth_token(token: str) -> dict | None:
    """
    Simulates an expensive token validation — LDAP lookup or JWT decode.
    Returns the decoded claims dict or None if invalid.
    """
    valid_tokens = {
        'tok_admin_abc': {'user': 'alice', 'role': 'admin', 'org': 'eng'},
        'tok_user_xyz': {'user': 'bob', 'role': 'viewer', 'org': 'sales'},
    }
    return valid_tokens.get(token)

def compute_body_hash(body: dict) -> str:
    """Simulates body integrity check — hash of serialised payload."""
    import json
    return hashlib.md5(json.dumps(body, sort_keys=True).encode()).hexdigest()[:8]

requests = [
    APIRequest('POST', '/api/deploy', {'service': 'payments'}, 'tok_admin_abc'),
    APIRequest('GET',  '/api/status', {}, 'tok_user_xyz'),
    APIRequest('POST', '/api/deploy', {'service': 'auth'}, 'tok_invalid'),
    APIRequest('DELETE', '/api/config', {}, 'tok_admin_abc'),
]

print('=== Walrus in match/case guard clause ===')

for req in requests:
    match req:
        case APIRequest(method='POST', path=path, body=body, auth_token=token) \
                if (claims := validate_auth_token(token)) and claims.get('role') == 'admin':
            # 'claims' is captured in the guard — available in the body without re-calling.
            # validate_auth_token() ran exactly once. The role check uses the same result.
            body_hash = compute_body_hash(body)
            print(f'  AUTHORISED POST to {path}')
            print(f'    Authorised by: {claims["user"]} ({claims["role"]})')
            print(f'    Body hash: {body_hash}')

        case APIRequest(method='GET', auth_token=token) \
                if (claims := validate_auth_token(token)):
            # Even for GET, walrus in the guard means one validation call.
            print(f'  READ access for {claims["user"]} to {req.path}')

        case APIRequest(method=method, auth_token=token) \
                if not validate_auth_token(token):
            # Here we don't need the claims value — just the truthiness check.
            # Walrus would add noise. Plain call is correct.
            print(f'  REJECTED {method} {req.path} — invalid token')

        case _:
            print(f'  FORBIDDEN {req.method} {req.path} — insufficient privileges')

print()
print('=== Where match/case binding makes walrus redundant ===')

responses = [
    {'status': 200, 'data': {'id': 42, 'name': 'Alice'}},
    {'status': 404, 'error': 'Not found'},
    {'status': 200, 'data': {'id': 99, 'name': 'Bob'}},
]

for response in responses:
    match response:
        case {'status': 200, 'data': {'id': user_id, 'name': user_name}}:
            # Pattern matching already binds user_id and user_name.
            # No walrus needed — the binding IS the pattern match.
            print(f'  Success: user {user_id} — {user_name}')
        case {'status': 404, 'error': error_msg}:
            print(f'  Not found: {error_msg}')
        case {'status': status_code}:
            print(f'  Unexpected status: {status_code}')

# io/thecodeforge/walrus_common_mistakes.py
# Five mistakes — each with the wrong version, the right version,
# and an explanation of exactly what goes wrong.

import hashlib
import re

def transform(x: float) -> float:
    return x ** 2.5

def fetch_config(key: str) -> dict | None:
    configs = {'db': {'host': 'localhost', 'port': 5432}}
    return configs.get(key)

def build_connection_string(config: dict) -> str:
    return f"{config['host']}:{config['port']}"

# ============================================================
# MISTAKE 1: Missing parentheses — binds a boolean silently.
# No SyntaxError. Wrong result. The bug that takes 45 minutes on-call.
# ============================================================
print('--- Mistake 1: Precedence trap ---')
data = [2, 4, 6, 8]

# WRONG: val := transform(x) > 20 is parsed as val := (transform(x) > 20)
# 'val' is True or False — not the float you wanted.
wrong = [val for x in data if (val := transform(x) > 20)]
print(f'  Wrong output (booleans): {wrong}')  # [True, True, True]

# CORRECT: parentheses force := to bind the float first.
correct = [val for x in data if (val := transform(x)) > 20]
print(f'  Correct output (floats): {correct}')  # [32.0, 181.0, 466.7, ...]

print()

# ============================================================
# MISTAKE 2: Assuming leaked variable holds the last PASSING value.
# It holds the last ASSIGNED value — regardless of the filter.
# ============================================================
print('--- Mistake 2: Last assigned vs last passing ---')
readings = [35.7, 29.4, 41.2, 15.0]  # 35.7 and 41.2 pass threshold 30.0
high = [r for r in readings if (captured := r) >= 30.0]
print(f'  High readings: {high}')              # [35.7, 41.2]
print(f'  captured after: {captured}')         # 15.0 — last assigned, NOT 41.2
print(f'  Last passing value: {high[-1]}')     # 41.2 — use the list, not the leaked var

print()

# ============================================================
# MISTAKE 3: Chaining walrus for dependent checks.
# Ambiguous failure point — hard to debug under pressure.
# ============================================================
print('--- Mistake 3: Chained walrus — ambiguous failure ---')

# WRONG: which step failed? You must check both variables.
if (cfg := fetch_config('missing_key')) and (conn := build_connection_string(cfg)):
    print(f'  Connected: {conn}')
else:
    # cfg is None — but if cfg had been truthy and build_connection_string failed,
    # you'd need to check both cfg and conn to diagnose. In production, 'both'
    # means reading two variables at 2 AM instead of one.
    print(f'  Failed. cfg={cfg}')  # cfg=None — but the failure mode is not obvious from code

# CORRECT: explicit guards — each failure point is immediately named.
cfg = fetch_config('db')
if not cfg:
    print('  No config found for key.')
else:
    conn = build_connection_string(cfg)
    print(f'  Connected: {conn}')

print()

# ============================================================
# MISTAKE 4: Walrus in a lambda body.
# SyntaxError — PEP 572 explicitly forbids this in all contexts.
# ============================================================
print('--- Mistake 4: Lambda + walrus = SyntaxError ---')

# WRONG (uncomment to see SyntaxError):
# process = lambda x: (result := x * 2 + 1)

# CORRECT: if you need a walrus-like binding in a callable, use a named function.
def process(x: float) -> float:
    result = x * 2 + 1
    return result

print(f'  Named function result: {process(5.0)}')  # 11.0

print()

# ============================================================
# MISTAKE 5: Walrus for trivially cheap operations.
# Signals 'important capture here' when nothing important is happening.
# Misleads readers about the code's intent.
# ============================================================
print('--- Mistake 5: Walrus where plain assignment is the right tool ---')

passwords = ['weak', 'Str0ngPass', 'S3cureKey']

# WRONG: := on len() signals something meaningful is being captured.
# len() is O(1) — there is no redundant call being eliminated.
if (n := len(passwords)) > 0:
    print(f'  Walrus: {n} candidates to process')  # works but misleads

# CORRECT: plain assignment. One line. Zero ambiguity.
n = len(passwords)
if n > 0:
    print(f'  Plain: {n} candidates to process')

# Without walrus: double evaluation
def expensive(x):
    # Simulate expensive computation
    return x * 2

data = [1, 2, 3, 4, 5]
results = [expensive(x) for x in data if expensive(x) > 5]
print(results)  # [6, 8, 10]

# With walrus: single evaluation
results = [val for x in data if (val := expensive(x)) > 5]
print(results)  # [6, 8, 10]
print(val)  # Note: val leaks to enclosing scope (10)

# Traditional while loop with duplication
with open('data.txt') as f:
    line = f.readline()
    while line:
        print(line.strip())
        line = f.readline()

# Walrus operator version
with open('data.txt') as f:
    while line := f.readline():
        print(line.strip())

# Example with additional condition
while (line := f.readline()) and line.strip():
    print(line)

# Example that sparked debate: nested walrus
# Some found this unreadable:
if (a := some_func()) and (b := a.method()) and (c := b.result()):
    process(c)

# Equivalent without walrus:
a = some_func()
if a:
    b = a.method()
    if b:
        c = b.result()
        if c:
            process(c)

# The walrus version is shorter but arguably harder to debug.