Scope/Function names and labels: Difference between revisions

In addition, functions etc. declared between IF and THEN are in scope in the THEN and ELSE parts, but

declarations in the THEN part and not visible in the ELSE part (and vice versa), so the following is invalid:

...

THEN

...

l1: ...

Similarly, declarations between WHILE and DO are in scope between DO and OD and those declared between CASE and IN are visible in the IN and OUT parts of a CASE.

<br>

=={{header|AWK}}==

In awk, function names are always global and can be referenced in sections of code appearing before the definition:

BEGIN {

sayhello() # Call the function defined below

function sayhello {

print "Hello World!" # Outputs a message to the terminal

Note that the awk extraction and reporting language is data driven and does not support arbitary line labels.

 

=={{header|BASIC}}==

Line numbers are used instead of labels. These are also immediately accessible as soon as the line is entered, even if the program is not run:

The visibility of functions depends on the implementation. Most versions of basic will allow a function to be referenced from a point in the code prior to its definition. However, other implementations may require the function definition to be run, before it can be used:

20 PRINT FN S(2): REM THIS WILL WORK

30 PRINT FN C(2): REM CALLING A FUNCTION PRIOR TO DEFINITION MAY NOT WORK

60 END

9000 DEF FN C(A)=A*A*A

 

=={{header|bc}}==

There are no labels in bc.

 

define f(x) {

return(x)

return(x - 1)

}

 

{{Out}}

Demonstrating function scope as well as goto in a C program invariably leads to code like the one below. The [http://en.wikipedia.org/wiki/Scope_(computer_science)#C Wikipedia article] is a good starting point.

 

#include <stdio.h>

 

printf("If you are trying to figure out what happened, you now understand goto.\n");

return 0;

 

{{out}} Example run:

If you are trying to figure out what happened, you now understand goto.

</pre>

 

=={{header|Eiffel}}==

 

All features are assigned (at compile-time) to a particular scope defined by the most-recently preceding feature clause. Various feature clauses are given below, from least restrictive (most visible) to most restrictive (most hidden).

class X

feature -- alias for "feature {ANY}"

-- features following this clause are only visible to this particular instance of X

 

 

=={{header|Erlang}}==

There are no labels.

 

-module( a_module ).

 

 

local_function() -> 2.

 

=={{header|Factor}}==

Each word belongs to a vocabulary. Vocabularies may be added to the vocabulary search path to put their words in scope. For example, to use the <code>+</code> word:

 

Words are visible in the vocabulary where they are defined. But only after the point where they have been defined.

IN: hello-vocab

 

hello ! error; hello hasn't been defined yet

: hello ( -- ) "Hello, world!" print ;

 

This restriction can be lifted through the use of <code>DEFER:</code>.

 

IN: hello-vocab

 

hello ! visible here

: hello ( -- ) "Hello, world!" print ;

 

 

A function definition, either a top-level declaration or a function literal, represents a function block.

 

 

import (

 

// ex.x() non-exported function not visible here

 

import (

func x() { // not exported, x not upper case.

panic("top level x")

{{out}}

<pre>

 

Labels can only be declared in function blocks. The scope is the function block where the label is declared excluding any nested function blocks.

 

import "fmt"

}

 

{{out}}

<pre>

Functions are considered global in haskell and can be referenced in the sections of code appearing before the function definition. The following code illustrates the same. add2 was declared after add3 and used in add3. The variables x,y and z are local to the function.

 

add3 :: Int -> Int-> Int-> Int

add3 x y z = add2 x y + z

 

main :: putStrLn(show (add3 5 6 5))

{{Output}}

<pre>

In the function below the functions g and h are local to the function getSquaredSum. They cannot be called from anywhere outside the function.

 

getSquaredSum :: Int-> Int-> Int

getSquaredSum x y = g x + h y

g a = a*a

h b = b*b

{{Output}}

<pre>

'''Local''' scope, names defined using =. will have local scope if a block scope exists.

 

 

'''Locale''' scope, names defined using =: will have locale scope (and the '''base''' locale is used by default).

 

 

Names may include a locale qualifier. A locative is a qualified name. Locale qualifiers contain two '''_''' characters, are a suffix on what would be the unqualified name. Locale qualifiers come in two forms: absolute and relative. Relative locale qualifiers use another name in the current locale to identify the target locale. Absolute locatives place the locale name between the two '''_''' characters, while relative locatives name the locale reference following the pair of '''_''' characters.

 

d=: <'test'

e__d=: 4

b + e_test_

 

If a local definition exists for a name, it is an error to use use =: to assign that name (use a locative instead of the unqualified name if you really need to do this).

 

f=. 6

g=: 7

)

|domain error

 

Meanwhile, there is a global current locale (default: '''base''') but each verb's definition is evaluated with the current locale being the locale where that verb was defined.

Labels are available in explicit definitions, and are names beginning with '''label_''' and ending with a '''.'''. You may use them with a goto which is a name beginning with '''goto_''' and ending with a '''.'''. Use of labels is restricted to the scope where they are defined, and they cannot be used to enter control structures (except in the sense of the normal entry point).

 

if. y do.

echo 0

example 0

2

 

=={{header|jq}}==

A similar rule applies to two inner functions defined within the same enclosing function. Otherwise, inner functions of the same

name can co-exist. In particular, a function named NAME may define an inner function of the same name. For example:

def NAME: 2;

1, NAME; # this calls the inner function, not the outer function

 

 

'''Mutually Defined Functions'''

The "declare-before-use" rule means that two top-level functions cannot be defined in terms of each other. Consider the following example:

There are several possible workarounds using inner functions. For example, if both F and M must be top-level functions, we could define them as follows:

def M(x): if x == 1 then F(x) else 2 end;

if x == 0 then M(x) else 1 end;

 

If F and M are not required to be top-level functions, then both F and M could be defined as inner functions of the same enclosing function.

 

 

The following program illustrates some of these usages.

 

// top level function visible anywhere within the current module

l() // invokes lambda

println("Good-bye!") // will be executed

 

{{out}}

=={{header|Lua}}==

In Lua, variables are global by default, but can be modified to be local to the block in which they are declared.

foo()

local function foo() print("local module") end -- local to the current block (which is the module)

end -- close the block (and thus its scope)

foo() -- module-level local still exists

{{out}}

<pre>global

There are statements Goto and Gosub as in Basic, including On Goto and On Gosub. We can make simple routines using Return to return from them.We can jump out from a block of code. We can't do the opposite, to enter in a block of code from outside. We can't jump out of Module or Function block, we can exit only using Exit or Break statements (Break exit on multiple blocks, Exit exit the current block). So Goto used to exit from a specific inner block to some block above it.

 

Function Master {

Module Alfa {

\\ No variables exist after the return from Master()

Print Valid(M)=False

 

=={{header|Nim}}==

Note that blocks are allowed anywhere where code is allowed, and so are labels. This is perfectly valid:

 

 

=={{header|Objeck}}==

=={{header|Perl}}==

Perl allows various ways to futz with scope, but keeping it simple: Routines are package-scoped, and in each package the final definition of the routine is the one that is used throughout. Labels are generally also package-scoped, except when it comes to <code>goto</code>; let's don't even go there.

 

sub logger { print shift . ": Dicitur clamantis in deserto." }; # discarded

sub logger {

print shift . ": This thought intentionally left blank.\n" # routine for 'main' package

{{out}}

<pre>A: This thought intentionally left blank.

 

=={{header|PL/I}}==

Functions are normally internal to a program. If they are at the nesting level

immediately within the program, they are accessible from anywhere in the program.

Functions can be compiled separately, and then linked with a program

in which case they are globally accessible.

 

=={{header|PowerShell}}==

 

You can specify the scope of a function. For example, the function is added to the global scope in the following example:

function global:Get-DependentService

{

Get-Service | Where-Object {$_.DependentServices}

}

When a function is in the global scope, you can use the function in scripts, in functions, and at the command line.

 

 

For more information about scope in Windows PowerShell, see about_Scopes

Get-Help about_Scopes

 

=={{header|Python}}==

=={{header|Racket}}==

Racket inherits the strict lexical-scopedness of Scheme, so function bindings (like any other bindings) are visible only within their scope. For example

(define (foo x)

(define (bar y) (+ x y))

(foo 1) ; => 3

(bar 1) ; => error

but that applies only to the *bindings* -- the actual function values (like other values) can be passed around freely:

(define (foo x)

(define (bar y) (+ x y))

(foo 1) ; => #<procedure:bar>

((foo 1) 2) ; => 3

 

But it should be noted that Racket is flexible enough to make it possible to implement other kinds of scope.

</pre>

 

say log(); # prints: outer

 

# call the original overridden CORE routine

say &CORE::log(e); # prints: 1 ( natural log of e )

 

Labels are less interesting and are typically useful only for control flow in looping constructs. They generally follow the same scoping rules as "my" variables. There is nearly always easier ways to do control flow though, so they aren't heavily used.

::::: (optional blanks)

::::::: ────(a repeat of the above as many times as is possible on a line of code)────

blarney = -0 /*just a blarney & balderdash statement*/

signal do_add /*transfer program control to a label.*/

add.2.args: procedure; parse arg x,y; return x+y /*first come, first served ···*/

add.2.args: say 'Whoa Nelly!! Has the universe run amok?' /*didactic, but never executed*/

'''output'''

<pre>

 

=={{header|Ring}}==

# Project : Scope/Function names and labels

 

func welcome(name)

see "hello " + name + nl

Output:

<pre>

=={{header|Ruby}}==

'def' starts the definition of a method, and 'end' ends it - no cute little curly braces.

def welcome(name)

puts "hello #{name}"

$name = STDIN.gets

welcome($name)

'''output'''

<pre>

 

=={{header|Scala}}==

val c = new C()

val d = new D()

println("Good-bye!") // will be executed

 

 

=={{header|Sidef}}==

In Sidef, the same rule which is applied to variable scoping, is applied to functions and classes as well, which means that a function defined inside another function is not visible outside the current scope.

func outer {

func inner {}; # not visible outside

class Outer {

class Inner {}; # not visisble outside

 

=={{header|Tcl}}==

There are a number of different symbol types in Tcl, all of which are handled independently. Each namespace contains a mapping from (simple) command names to command implementations; when a command is looked up, the search is done by looking in the current namespace, then in the namespaces on that namespace's path (which is usually empty), and finally in the global namespace. There are ''no'' local commands (unlike with variables, though a lambda expression in a variable can act very similarly to a command). Commands only have a mapping after they have been created; the <code>proc</code> “declaration” is just a command that creates a procedure at the point where it is called.

 

proc doFoo {a b c} {

puts [expr {$a + $b*$c}]

}

Tcl does not support labels, either outside or inside procedures. (Other mechanisms are used for jumps and state machines.)

 

There is no lookahead in the shell, so functions cannot be called until their definition has been run:

 

multiply 3 4 # This will not work

echo $? # A bogus value was returned because multiply definition has not yet been run.

 

multiply 3 4 # Ok. It works now.

 

The shell does not support the use of arbitrary line labels.

 

=={{header|Wren}}==

 

The following example illustrates these points.

 

var func = Fn.new { System.print("func has been called.") }

}

 

 

{{out}}

 

(with line 1 uncommented)

 

(with only line 7 uncommented)

func has been called.

Null does not implement 'init()'.

</pre>

 

 

Functions have two modifiers, public (the default) and private. Private is the same as public inside the compilation unit, outside that unit/file, a private function can only be accessed via reflection.

 

=={{header|ZX Spectrum Basic}}==

Functions are visible as soon as they are entered, even if the program is not run. Line numbers are used instead of labels. These are also immediately accessible as soon as the line is entered, even if the program is not run:

9010 DEF FN s(x)=x*x

 

PRINT FN s(5): REM This will work immediately

 

{{omit from|GUISS|does not have functions or labels}}