Forward Declarations in Python to Prevent NameErrors for Functions Defined Later

In Python, attempting to call a function before it has been defined can result in a NameError. While code reorganization may seem like the only solution, there are alternative approaches.

One method is to forward-declare a function by wrapping its invocation within a separate function. This allows the function to be called before it is defined without triggering a NameError.

For example, the following code will fail:

print("\n".join([str(bla) for bla in sorted(mylist, cmp = cmp_configs)]))

Because the cmp_configs function has not been defined yet. To forward-declare it, we can wrap the invocation:

def forward_declare_cmp_configs():
    print("\n".join([str(bla) for bla in sorted(mylist, cmp = cmp_configs)]))

forward_declare_cmp_configs()

def cmp_configs():
    ...

Now, the forward_declare_cmp_configs() function can be called before cmp_configs() is defined, and the original code will execute without error.

Another scenario where forward declaration is useful is in recursive functions. For instance, the following code would fail:

def spam():
    if end_condition():
        return end_result()
    else:
        return eggs()

def eggs():
    if end_condition():
        return end_result()
    else:
        return spam()

To forward-declare the recursive calls, we can use a nested function approach:

def spam_outer():
    def spam_inner():
        if end_condition():
            return end_result()
        else:
            return eggs()

    def eggs():
        if end_condition():
            return end_result()
        else:
            return spam_inner()

    return spam_inner()

spam_outer()()

Remember, while forward declarations can be useful, the general rule in Python is to define a function before its first usage.