Scoping in nested functions: How should it work?
Ian Tegebo
seemingly counter-intuitive behavior:
------------------------------------
function! Outer()
let outer_var = 0
function! Inner()
let outer_var += 1
endfunction
call Inner()
echo outer_var
endfunction
call Outer()
-------------------------------------
The result, when I run this from 7.1.156, is that 'Inner' reports
'outer_var' as
unknown. I was expecting '0' but would eventually like to have my 'Inner'
use 'outer_var' as state via dictionaries or some other mechanism. It's
disturbing that 'outer_var' is not available to 'Inner'.
Am I missing something? Is this the intended behavior? If so, where else
can I read more about scoping? I've been reading usr_41.txt and eval.txt.
--
Ian Tegebo
Tony Mechelynck
Inside a function, a variable name without a scope is the same as l: -- i.e.,
local to the _current_ function. Now there is no outer_var defined _inside_
the Inner() function, so it properly gives an error.
Variables local to Outer() are not accessinle to Inner(). From both of them
you can access most variables except function arguments and function-local
variables.
See ":help internal-variables" (and what it resends to) for details.
Best regards,
Tony.
--
If you cannot convince them, confuse them.
-- Harry S Truman
ap
On Jan 8, 10:00 pm, "Ian Tegebo" <ian.teg...@gmail.com> wrote:
> I'm exploring functional programming with vimL and immediately ran into
> seemingly counter-intuitive behavior:
>
> ------------------------------------
> function! Outer()
> let outer_var = 0
> function! Inner()
> let outer_var += 1
> endfunction
> call Inner()
> echo outer_var
> endfunction
>
> call Outer()
> -------------------------------------
>
> The result, when I run this from 7.1.156, is that 'Inner' reports
> 'outer_var' as
> unknown. I was expecting '0' but would eventually like to have my 'Inner'
> use 'outer_var' as state via dictionaries or some other mechanism. It's
> disturbing that 'outer_var' is not available to 'Inner'.
>
> Am I missing something?
>
to
this :
------------------------------------
function! Outer()
let outer_var = 0
echo outer_var
endfunction
function! Inner()
let outer_var += 1
endfunction
-------------------------------------
As Tony pointed out, you have 2 different local variables.
-ap
ap
Btw where did you get the idea vimscript is a functional language ?
-ap
Ben Schmidt
> to this :
>
> ------------------------------------
> function! Outer()
> let outer_var = 0
> call Inner()
> echo outer_var
> endfunction
>
> function! Inner()
> let outer_var += 1
> endfunction
>
> call Outer()
> -------------------------------------
Except that the Inner function is defined before calling Outer, not during the
call of Outer.
It might help to realise that in Vim, 'function' is a command that defines a
function in global scope (or script scope sometimes). You can run this command
whenver you like to define a function, and it always does the same thing. It is
NOT a program syntactical construct that defines a function at the point where it
is placed in the code.
Ben.
Send instant messages to your online friends http://au.messenger.yahoo.com
Ian Tegebo
"I'm exploring a functional programming style within vimL..."
Also, what do people call the language vim uses for extensions, e.g.
vimL(anguage), vim-script?
--
Ian Tegebo
Ben Schmidt
Usually vimscript.