so local functions cannot be recursive?

Yes they can, but their declarations are not hoisted, meaning you cannot have a reference to a local function that is declared later.

hmm. How does it work in all other languages then?..

Can you give an example?

example of what?

example of other language that has this

ah. F#

How does C# deal with the fact that

Two

can reference local variables declared in

Foo

?

I just was about to implement an FSM inside

actor { }

with a bunch of local functions and oops.

In Javascript you will get a

ReferenceError

at runtime

I'm not sure I understand the problem.

You are calling

one

, which calls

two

, which then references

x

. But at the time you are calling it

x

is not even declared or assigned yet

why it's not declared? I don't think C# executes code line by line 🙂

You can work around this by using lambdas instead of actual functions and using lateinit declaration:

fun foo() {
    lateinit var two: () -> Unit
    fun one() {
        two()
    }
    two = {
        
    }
    one()
}

Even if it is declared, it is certainly not assigned

@vaskir can you just translate that javascript code into C# and run it and see what happens? 😉

No. That is completely different to what I posted.

nope, the one that is said to produce

Uncaught ReferenceError: x is not defined

.

@diesieben07 That's not the point though, @vaskir doesn't want to call it earlier, just declare them and use them afterwards

Yes, I am just explaining why this is not allowed in Kotlin.

Yeah, which is exactly is wanted here.

"explode at runtime" should never be wanted 😛

So there's never a usecase for using

!!

then?

I have written a lot of Kotlin and I've yet to use

!!

outside of quick and dirty experimental code

use case for

!!

is java interop I think, if you have only kotlin, then I don’t see much use

In Java interop you have platform types

Please propose a better way of doing what @vaskir is trying to do then

Well, there was only a very limited contrived example posted.

@diesieben07 And what if it does? You can simply define all your functions at the top of the closure, and do any code that actually does something afterwards. Yeah, it's not checked by the compiler so it depends on the programmer checking that, but it's simple enough to keep straight. I really don't understand why you you're insisting to bring your example of doing something between the functions into it

at compile time

For now just use regular functions instead of local functions

or use another lang

exactly

Scala allows forward referencing to local functions. It solves the problem mentioned by Take Weiland by imposing some restrictions on how local variables can be positioned. Basically what I understand about the restriction is that a local function, say foo() cannot forward reference another local function, say bar() which references a local variables declared after foo() is declared. This restriction is fair and makes sense, and it does not limit us from a lot of good use cases for local functions.