I’m trying to understand how method definitions work inside functions. (Is this mentioned anywhere in the documentation?) From this post I learned that all method definitions for a given local function `f`

are combined to an anonymous functions, and each definition is replaced by assigning this anonymous function to `f`

. It doesn’t matter where the method definitions occur inside the enclosing function. For example, the function

```
function a()
f() = 0
return f
f(x) = x
end
```

returns a function with *two* methods. If there are two methods with the same signature, then the first one is ignored, and the user gets a warning.

However, there are cases where this explanation doesn’t seem to work (with Julia 1.6.1). For instance, I get

```
function b1()
if true
f() = 0
else
f(x) = x
end
end
b1() # generic function with 2 methods (as expected)
```

but

```
function b2()
if false
f() = 0
else
f(x) = x
end
end
b2() # UndefVarError: f not defined
```

The picture gets even confusing if one adds empty functions. Here are some examples:

```
function c1()
function f end
return f
end
c1() # generic function with 0 methods (as expected)
function c2()
function f end
return f
f() = 0
end
c2() # UndefVarError: f not defined
function c3()
g = function f end
return g
end
c3() # generic function with 0 methods (as expected)
function c4()
g = function f end
return g
f() = 0
end
c4() # nothing (which is not even a function)
function c5()
if false
f() = 0
else
function f end
end
end
c5() # nothing
```

Is this the intended behavior? If yes, what are the rules behind this?