Cases

These cases progress from simple function ordering to runtime-sensitive dependencies.

1. Function References

The caller moves above the helpers it uses. Function bodies are lazy, so helpers may safely be defined below the caller.

Before:

def d() -> str:
    return "d"


def c() -> str:
    return "c"


def b() -> str:
    return "b"


def a(key: str):
    res = b()
    mapping = {"c": c}
    sequence = [d]
    return res, mapping[key](), sequence

After:

def a(key: str):
    res = b()
    mapping = {"c": c}
    sequence = [d]
    return res, mapping[key](), sequence


def b() -> str:
    return "b"


def c() -> str:
    return "c"


def d() -> str:
    return "d"

2. Recursive Helper Chain

A recursive function stays first, followed by the non-recursive helpers it reaches.

Before:

def leaf() -> str:
    return "leaf"


def helper() -> str:
    return leaf()


def recursive(items: list[str]) -> str:
    if items:
        return recursive(items[1:])
    return helper()

After:

def recursive(items: list[str]) -> str:
    if items:
        return recursive(items[1:])
    return helper()


def helper() -> str:
    return leaf()


def leaf() -> str:
    return "leaf"

3. Nested Functions

Nested scopes are reordered independently, preserving the same top-down reading flow inside the outer function.

Before:

def a() -> str:
    def b() -> str:
        def d() -> str:
            return "d"

        def e() -> str:
            return d()

        return e()

    def c() -> str:
        return b()

    return c()

After:

def a() -> str:
    def c() -> str:
        return b()

    def b() -> str:
        def e() -> str:
            return d()

        def d() -> str:
            return "d"

        return e()

    return c()

4. Class Methods

Methods are reordered within the class body. Instance and static method references follow the public method that uses them.

Before:

class Greeting:
    @staticmethod
    def format_punctuation() -> str:
        return "!"

    def format_name(self) -> str:
        return "Ada"

    def greet(self) -> str:
        return f"Hello, {self.format_name()}{Greeting.format_punctuation()}"

After:

class Greeting:
    def greet(self) -> str:
        return f"Hello, {self.format_name()}{Greeting.format_punctuation()}"

    def format_name(self) -> str:
        return "Ada"

    @staticmethod
    def format_punctuation() -> str:
        return "!"

5. Eager Definition Dependencies

Some expressions are evaluated immediately: decorators, default arguments, and class-body values. Those dependencies stay above the chunk that needs them, even when a lazy caller can move first.

Before:

def main() -> str:
    service = Service()
    return service.handle()


def instrument(func):
    return func


def normalize(value: str) -> str:
    return value.strip().upper()


class Service:
    normalizer = normalize

    @instrument
    def handle(self, normalizer=normalize) -> str:
        return normalizer(" ok ")

After:

def main() -> str:
    service = Service()
    return service.handle()


def normalize(value: str) -> str:
    return value.strip().upper()


def instrument(func):
    return func


class Service:
    normalizer = normalize

    @instrument
    def handle(self, normalizer=normalize) -> str:
        return normalizer(" ok ")