@@ -9,6 +9,9 @@
 These features give you fine-grained control over your function signatures.
 """
 
+from collections.abc import Callable
+from typing import Any
+
 
 def traditional_function(a: int, b: int, c: int) -> int:
     """A traditional function where all parameters can be passed either way.
@@ -84,158 +87,87 @@ def complex_signature(a: int, b: int, /, c: int, d: int = 10, *, e: int, f: int
     return a + b + c + d + e + f
 
 
-def main() -> None:
-    # Traditional function: can be called either way
-    assert traditional_function(1, 2, 3) == 6
-    assert traditional_function(a=1, b=2, c=3) == 6
-    assert traditional_function(1, b=2, c=3) == 6
+def distance(x1: float, y1: float, x2: float, y2: float, /) -> float:
+    """Calculate distance between two points.
 
-    # Positional-only function: must use positional arguments
-    assert positional_only(5, 3) == 8
-
-    # Trying to use keyword arguments with positional-only parameters
-    # will raise a TypeError
-    positional_error = False
-    try:
-        # This will fail because 'a' and 'b' are positional-only
-        positional_only(a=5, b=3)  # type: ignore [call-arg]
-    except TypeError:
-        positional_error = True
-    assert positional_error is True
-
-    # You also can't mix positional and keyword for positional-only params
-    positional_error2 = False
-    try:
-        # This will fail because 'b' is positional-only
-        positional_only(5, b=3)  # type: ignore [call-arg]
-    except TypeError:
-        positional_error2 = True
-    assert positional_error2 is True
+    The parameter names here are somewhat arbitrary (could be p1_x, etc.)
+    so we make them positional-only to give us flexibility to rename them
+    without breaking existing code.
+    """
+    return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
 
-    # Keyword-only function: must use keyword arguments
-    assert keyword_only(x=4, y=5) == 20
 
-    # Trying to use positional arguments with keyword-only parameters
-    # will raise a TypeError
-    keyword_error = False
-    try:
-        # This will fail because 'x' and 'y' are keyword-only
-        keyword_only(4, 5)  # type: ignore [misc]
-    except TypeError:
-        keyword_error = True
-    assert keyword_error is True
+def create_user(username: str, *, admin: bool = False, active: bool = True, send_email: bool = False) -> dict[str, object]:
+    """Create a user with clear intent for optional parameters.
 
-    # Mixed parameters demonstrate all three types
-    result = mixed_parameters("first", "second", kw_only="third")
-    assert result == "first-second-third"
+    Making admin, active, and send_email keyword-only ensures that
+    callers must specify exactly what they're setting, improving
+    readability and preventing accidental mistakes.
+    """
+    return {"username": username, "admin": admin, "active": active, "send_email": send_email}
 
-    # The middle parameter can be passed either way
-    result2 = mixed_parameters("first", pos_or_kw="second", kw_only="third")
-    assert result2 == "first-second-third"
 
-    # But positional-only must be positional
-    mixed_error = False
+def assert_raises_type_error(fn: Callable[..., Any], *args: Any, **kwargs: Any) -> None:
+    """Verify that calling fn with given arguments raises a TypeError."""
+    raised = False
     try:
-        mixed_parameters(pos_only="first", pos_or_kw="second", kw_only="third")  # type: ignore [call-arg]
+        fn(*args, **kwargs)
     except TypeError:
-        mixed_error = True
-    assert mixed_error is True
+        raised = True
+    assert raised is True
 
-    # And keyword-only must be keyword
-    mixed_error2 = False
-    try:
-        mixed_parameters("first", "second", "third")  # type: ignore [misc]
-    except TypeError:
-        mixed_error2 = True
-    assert mixed_error2 is True
 
-    # Positional-only with defaults
-    assert positional_with_defaults(5) == 15  # Uses default b=10
-    assert positional_with_defaults(5, 20) == 25  # Overrides b with 20
+def main() -> None:
+    # Traditional function: can be called either way
+    assert traditional_function(1, 2, 3) == 6
+    assert traditional_function(a=1, b=2, c=3) == 6
+    assert traditional_function(1, b=2, c=3) == 6
 
-    # Even with defaults, must use positional syntax
-    positional_default_error = False
-    try:
-        positional_with_defaults(a=5, b=20)  # type: ignore [call-arg]
-    except TypeError:
-        positional_default_error = True
-    assert positional_default_error is True
+    # Positional-only function: must use positional arguments
+    assert positional_only(5, 3) == 8
+    # Arguments before / cannot be passed by keyword name
+    assert_raises_type_error(positional_only, a=5, b=3)
+    assert_raises_type_error(positional_only, 5, b=3)
 
-    # Keyword-only with defaults
-    assert keyword_with_defaults() == 125  # Uses defaults: 5^3
-    assert keyword_with_defaults(x=2) == 8  # 2^3
-    assert keyword_with_defaults(y=2) == 25  # 5^2
-    assert keyword_with_defaults(x=3, y=4) == 81  # 3^4
+    # Keyword-only function: must use keyword arguments
+    assert keyword_only(x=4, y=5) == 20
+    # Arguments after * cannot be passed positionally
+    assert_raises_type_error(keyword_only, 4, 5)
 
-    # Must still use keyword syntax even when providing defaults
-    keyword_default_error = False
-    try:
-        keyword_with_defaults(2, 3)  # type: ignore [misc]
-    except TypeError:
-        keyword_default_error = True
-    assert keyword_default_error is True
+    # Mixed parameters demonstrate all three types
+    assert mixed_parameters("first", "second", kw_only="third") == "first-second-third"
+    assert mixed_parameters("first", pos_or_kw="second", kw_only="third") == "first-second-third"
+    # Positional-only must be positional, keyword-only must be keyword
+    assert_raises_type_error(mixed_parameters, pos_only="first", pos_or_kw="second", kw_only="third")
+    assert_raises_type_error(mixed_parameters, "first", "second", "third")
+
+    # Positional-only with defaults still requires positional passing
+    assert positional_with_defaults(5) == 15
+    assert positional_with_defaults(5, 20) == 25
+    assert_raises_type_error(positional_with_defaults, a=5, b=20)
+
+    # Keyword-only with defaults still requires keyword passing
+    assert keyword_with_defaults() == 125
+    assert keyword_with_defaults(x=2) == 8
+    assert keyword_with_defaults(y=2) == 25
+    assert keyword_with_defaults(x=3, y=4) == 81
+    assert_raises_type_error(keyword_with_defaults, 2, 3)
 
     # Complex signature: demonstrating all parameter types
-    # Minimal call with required params only
-    result3 = complex_signature(1, 2, 3, e=4)
-    assert result3 == 40  # 1+2+3+10(default)+4+20(default)
-
-    # Providing all parameters
-    result4 = complex_signature(1, 2, 3, 4, e=5, f=6)
-    assert result4 == 21  # 1+2+3+4+5+6
-
-    # Middle parameter 'c' can be passed by keyword
-    result5 = complex_signature(1, 2, c=3, e=4)
-    assert result5 == 40
-
-    # Parameter 'd' can also be passed by keyword
-    result6 = complex_signature(1, 2, 3, d=15, e=4)
-    assert result6 == 45  # 1+2+3+15+4+20
-
-    # But 'a' and 'b' must be positional
-    complex_error = False
-    try:
-        complex_signature(a=1, b=2, c=3, e=4)  # type: ignore [call-arg]
-    except TypeError:
-        complex_error = True
-    assert complex_error is True
-
-    # And 'e' must be keyword (even though 'f' has a default)
-    complex_error2 = False
-    try:
-        complex_signature(1, 2, 3, 10, 4)  # type: ignore [misc]
-    except TypeError:
-        complex_error2 = True
-    assert complex_error2 is True
-
-    # Practical use case: Positional-only is great for functions where
-    # parameter names are not meaningful or may change
-    def distance(x1: float, y1: float, x2: float, y2: float, /) -> float:
-        """Calculate distance between two points.
-
-        The parameter names here are somewhat arbitrary (could be p1_x, etc.)
-        so we make them positional-only to give us flexibility to rename them
-        without breaking existing code.
-        """
-        return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
-
+    assert complex_signature(1, 2, 3, e=4) == 40
+    assert complex_signature(1, 2, 3, 4, e=5, f=6) == 21
+    assert complex_signature(1, 2, c=3, e=4) == 40
+    assert complex_signature(1, 2, 3, d=15, e=4) == 45
+    assert_raises_type_error(complex_signature, a=1, b=2, c=3, e=4)
+    assert_raises_type_error(complex_signature, 1, 2, 3, 10, 4)
+
+    # Practical use case 1: Positional-only parameter renaming flexibility
     assert abs(distance(0, 0, 3, 4) - 5.0) < 0.01
 
-    # Practical use case: Keyword-only is great for boolean flags or
-    # optional parameters where the intent should be clear at call site
-    def create_user(username: str, *, admin: bool = False, active: bool = True, send_email: bool = False) -> dict[str, object]:
-        """Create a user with clear intent for optional parameters.
-
-        Making admin, active, and send_email keyword-only ensures that
-        callers must specify exactly what they're setting, improving
-        readability and preventing accidental mistakes.
-        """
-        return {"username": username, "admin": admin, "active": active, "send_email": send_email}
-
-    # Clear intent at call site
+    # Practical use case 2: Keyword-only clarity for optional flags
     user = create_user("john_doe", admin=True, send_email=True)
     assert user["admin"] is True
-    assert user["active"] is True  # Used default
+    assert user["active"] is True
     assert user["send_email"] is True
 
 
 
@@ -226,7 +226,8 @@ def process_json_data(data: object) -> str:
             return "Invalid data"
 
 
-def main() -> None:
+def verify_literal_and_sequence_patterns() -> None:
+    """Verify literal values, status codes, tuples, and sequence matching."""
     # Test literal pattern matching
     assert classify_number(0) == "zero"
     assert classify_number(1) == "one"
@@ -257,6 +258,9 @@ def main() -> None:
     assert analyze_sequence([1, 2, 3, 4]) == "First: 1, Rest: [2, 3, 4]"
     assert analyze_sequence("not a list") == "Not a list"
 
+
+def verify_guard_and_class_patterns() -> None:
+    """Verify guard expressions and class-based object decomposition."""
     # Test pattern matching with guards
     assert process_command(["quit"]) == "Quitting"
     assert process_command(["go", "north"]) == "Going north"
@@ -293,6 +297,9 @@ def main() -> None:
     # Test unknown shape
     assert describe_shape("unknown") == "Unknown shape"
 
+
+def verify_mapping_and_advanced_patterns() -> None:
+    """Verify dictionary structural patterns, OR patterns, AS patterns, and nesting."""
     # Test dictionary pattern matching
     user1 = {"type": "user", "name": "Alice", "age": 30}
     assert process_json_data(user1) == "User Alice is 30 years old"
@@ -328,6 +335,17 @@ def main() -> None:
     assert analyze_nested([["single", 42]]) == "Single value: 42"
     assert analyze_nested("invalid") == "Unknown structure"
 
+
+def main() -> None:
+    # 1. Literal and sequence pattern matching
+    verify_literal_and_sequence_patterns()
+
+    # 2. Guard conditions and class pattern matching
+    verify_guard_and_class_patterns()
+
+    # 3. Dictionary patterns, OR patterns, AS patterns, and nested structures
+    verify_mapping_and_advanced_patterns()
+
     # Pattern matching is particularly useful for parsing and handling
     # structured data like API responses, configuration files, or
     # abstract syntax trees in compilers/interpreters