Why don't recursive swift function definitions create issues with their initial 'values'?

Question

There are multiple interesting questions here about attempting to define recursive closures in Swift. I think the one with the clearest answers is this post asking the question of why one can't declare and define a recursive closure in the same line in Swift. However, they don't ask the reverse question. That is, if I can't create code like this:

var countdown = { i in
    print(i)
    if i > 1 {
        countdown(i - 1)
    }
}
// error: Variable used within its own initial value

Then why am I allowed to write code like this:

func countdown(_ i: Int) {
    print(i)
    if i > 1 {
        countdown(i - 1)
    }
}

What's so special about functions that makes them not have any issues when trying to call themselves within their own declaration? I understand the issue behind the closure: it's trying to capture a value (the closure itself) that doesn't yet exist. However, what I don't understand is why the function doesn't have the same problem. Looking at the Swift Book, we see that:

Global functions are closures that have a name and don’t capture any values.

Which is a half-answer: the function above doesn't cause issues because functions don't capture values. But then, how do functions do their work if they don't capture values (particularly recursive ones)?

Answer 1

Not quite sure what you're looking for by way of an answer. I mean, one simple answer is that this is how the Swift compiler works.

One reason could be that with a func expressions, e.g. func countdown(...) {}, the compiler can safely assume that the function will be defined by the time it invokes itself.

Whereas with variable definition (i.e. an expression where a variable acquires its value), it does not generally make such an assumption, because something like

var c = c + 1

clearly wouldn't work due to the same "Variable used within its own initial value" error.

That being said, the compiler probably could have special-cased the definition of closure-type variables since, unlike with non-closure variables, their actual value isn't needed at the time they are defined.

That's why a solution is to define the variable (or at least re-assure the compiler that it would be defined with !), so the compiler wouldn't complain:

var countdown: ((Int) -> Void)!
countdown = { i in
    print(i)
    if i > 1 {
        countdown(i - 1)
    }
}

Answer 2

One is a function and the other is a stored property and stored properties (and properties) are states and functions are actions, semantically speaking. And this is how the Swift compiler interprets your code and why it doesn't work.

In your example, countdown is compiled as a stored property by the compiler. You can convert the stored property into a computed property to make it behave more like a function, but not only will you lose the ability to pass it arguments but the property would still not be able to access itself in its own getter (because it's still a property and not a function).

The answer by New Dev is a syntax workaround that changes countdown from a stored property into a function—he declared it as a function and later assigned it a closure. You tried to jam a function into a property and wondered why Swift gave special treatment to one over the other—it didn't, you just made them two different types. And I specifically point this out because your question (as it appears to me) is why functions are treated differently from properties. And it's because functions and properties are two inherently different things.

/* This syntax tells the compiler that
   countdown is a stored property, hence
   the error of accessing self in the
   property's own getter. */
var countdown = { i in
    print(i)
    if i > 1 {
        countdown(i - 1)
    }
}

/* This syntax tells the compiler that
   countdown is a computed property, but
   this will still not compile because
   computed properties cannot take arguments
   or access self in the getter. */
var countdown: (Int) -> () { i in
    print(i)
    if i > 1 {
        countdown(i - 1)
    }
}

/* All this does is tell the compiler
   that countdown is of type function.
   This variable will no longer be compiled
   as a stored property. We've changed its
   type to function which is why it works. */
var countdown: ((Int) -> Void)!