Scope modifiers: Difference between revisions

Show the different scope modifiers available in your language and briefly explain how they change the scope of their variable or function.

If your language has no scope modifiers, note it.

 

=={{header|Ada}}==

In [[Ada]] declarative region of a package has publicly visible and private parts.

The private part is introduced by '''private''':

... -- Declarations placed here are publicly visible

private

... -- These declarations are visible only to the children of P

Correspondingly a type or object declaration may be incomplete in the public part providing an official interface. For example:

type T is private; -- No components visible

procedure F (X : in out T); -- The only visible operation

procedure V (X : in out T); -- Operation used only by children

N : constant T := (Component => 0); -- Constant implementation

 

===Bodies (invisible declarations)===

The keyword '''body''' applied to the packages, protected objects and tasks. It specifies an implementation of the corresponding entity invisible from anywhere else:

-- The implementation of P, invisible to anybody

procedure W (X : in out T); -- Operation used only internally

===Private children===

The keyword '''private''' can be applied to the whole package, a child of another package:

... -- Visible to the siblings only

private

... -- Visible to the children only

This package can be then used only by private siblings of the same parent P.

 

=={{header|AutoHotkey}}==

{{AutoHotkey case}}

 

assume_global()

_%member% := ""

Return (_%member%)

 

=={{header|Axe}}==

==={{header|Applesoft BASIC}}===

All variables are global by default, except the parameter which is local to the function. There are no scope modifiers.

20 DEF FN F(X) = X

30 DEF FN G(N) = X

40 PRINT FN F(2)

{{out}}

<pre>2

 

The scope modifier PRIVATE declares a variable static to a function; it sets the value to zero/NULL initially.

var2$ = "Global2"

PRINT "var2$ = """ var2$ """"

{{out}}

<pre>

One can think of each identifier as a stack. Function parameters and local identifiers are pushed onto the stack and shadow the values of identifiers with the same names from outer scopes. They are popped from the stack when the function returns. Thus a function that is called from another function has access to the local identifiers and parameters of its caller if itself doesn't use the same name as a local identifier/parameter. In other words, always the innermost value (the value at the top of the stack) for each identifier is visible, regardless of the scope level where it is accessed.

 

auto b

"Global scope (before call): b = "; b

"Global scope (before call): c = "; c

 

{{Out}}

Undeclared variables have always global scope and declared variables have always dynamic scope. Also the function argument (always called "arg" and never explicitly declared) has always dynamic scope. The Bracmat program contained in file "lex.bra" (see Bracmat on GitHub) analyses another Bracmat program to find the places where variables are not in lexical scope. Following the suggestions to declare such variables (and to remove declared, but unused variables) will improve the readability of the analysed code.

 

& 77:?y { y has global scope }

& ( double

& double$

& !x+!y

 

"Variables" in lambda expressions have lexical scope. But can of course not be varied.

 

 

=={{header|C}}==

 

'''file1.c'''

static int p; // p is "locale" and can be seen only from file1.c

 

v = v * 1.02; // update global v

// ...

 

'''file2.c'''

static int p; // a file-scoped p; nothing to share with static p

// in file1.c

// normally these things go into a header.h

 

 

=={{header|C sharp}}==

protected //visible to current class and to derived classes.

internal //visible to anything inside the same assembly (.dll/.exe).

//private | Yes | No | No || No | No

// C# 7.2:

If no modifier is specified, it defaults to the most restrictive one.<br/>

In case of top-level classes/structs/interfaces/enums this means internal, otherwise it means private.

Special case: explicit interface implementation.<br/>

When a class explicitly implements an interface method, it is 'hidden' and that method can only be accessed through the interface:

{

void Print();

}

}

Other declarations follow lexical scoping.<br/>

Visibility is determined by the enclosing braces { }<br/>

The next example declaims that <code>*bug*</code> has dynamic scope. Meanwhile, <code>shape</code> has lexical scope.

 

(declaim (special *bug*))

 

(let ((shape "circle") (*bug* "cockroach"))

(format t "~%Put ~A in your ~A..." *bug* shape)

 

The function <code>speak</code> tries to use both <code>*bug*</code> and <code>shape</code>. For lexical scope, the value comes from where the program ''defines'' <code>speak</code>. For dynamic scope, the value comes from where the program ''calls'' <code>speak</code>. So <code>speak</code> always uses the same "triangle", but can use a different bug.

 

=={{header|Delphi}}==

Can only be seen inside declared class.

 

Can be seen in descendent classes.

 

Can be seen from outside the class.

 

Same visibility as Public, but run time type information (RTTI) is generated, allowing these members to be viewed dynamically. Members need to be published in order to be streamed or shown in the Object Inspector.

 

Same visibility as Public, and used for Automation Objects. This is currently only maintained for backward compatibility.

 

Private and Protected members of a class are visible to other classes declared in the same unit. The "strict" modifier was added in Delphi 2005 to treat public and private members as private and protected, even from classes declared in the same unit.

 

=={{header|Déjà Vu}}==

Variables are lexically scoped in Déjà Vu. Doing a <code>set</code> or a <code>get</code> starts looking for <code>local</code> declarations in the current scope, going upward until the global scope. One can use <code>setglobal</code> and <code>getlocal</code> to bypass this process, and only look at the global scope.

if true:

!print a

!print getglobal :a

!print a

{{out}}

<pre>global

* a global variable

 

some_procedure(int: INTEGER; char: CHARACTER)

local

end

 

 

=={{header|Ela}}==

Variables in Ela are lexically scoped (pretty similar to Haskell) and can be declared using let/in and where bindings. Additionally Ela provides a 'private' scope modifier for global bindings:

 

pi = 3.14159

 

sum # private

 

Names declared with 'private' modifier are not visible outside of a module. All other bindings are visible and can be imported. It is an error to use 'private' modifier on local bindings.

=={{header|Erlang}}==

Erlang is lexically scoped. Variables, which must begin with an upper case letter, are only available inside their functions. Functions are only available inside their modules. Unless they are exported.

-module( a_module ).

 

 

add( N, N ) -> N + N.

 

{{out}}

** exception error: undefined function a_module:add/2

</pre>

 

=={{header|Free Pascal}}==

=={{header|Icon}} and {{header|Unicon}}==

Icon and Unicon data types are not declared and variables can take on any value; however, variables can be declared as to their scope. For more see [[Icon%2BUnicon/Intro#un-Declarations.2C_it.27s_all_about_Scope|un-Declarations it's all about scope]]. Additionally, Unicon supports classes with methods.

 

procedure one() # a global procedure (the only kind)

local var2 # used inside of procedures

static var3 # also used inside of procedures

 

Co-expressions (both languages) also redefine scope - any local variables referenced

First approximation: All variables are either "global" in scope, or are local to the currently executing explicit definition. Local names shadow global names. J provides kinds of assignment -- assignment to a local name (<tt>=.</tt>) and assignment to a global name (<tt>=:</tt>). Shadowed global names ("global" names which have the same name as a name that has a local definition) can not be assigned to (because this is typically a programming mistake and can be easily avoided by performing the assignment in a different execution context). Here's an interactive session:

 

B=: 2

C=: 3

2

D

 

Second approximation: J does not really have a global namespace. Instead, each object and each class has its own namespace. By default, interactive use updates the namespace for the class named 'base'. Further discussion of this issue is beyond the scope of this page.

 

=={{header|Java}}==

 

protected //only this class, subclasses of this class,

}

//can use x and y here, but NOT z

 

=={{header|JavaScript}}==

 

A named function definition (<code>function foo() { ... }</code>) is “hoisted” to the top of the enclosing function; it is therefore possible to call a function before its definition would seem to be executed.

 

=={{header|Julia}}==

<code> local x </code>introduces a new local variable x.

<br /><br />

julia> function foo(n)

x = 0

julia> foo(10)

0

Julia also has scopes based on modules. Variables within a standard module such as <code>MyModule; x = 0; end</code>need to be referred to with the module name prefix, such as <code>MyModule.x</code>, unless the variable is exported from the module with the <code> export</code> keyword.

 

 

4. Kotlin does not have static members as such but instead has 'companion objects' whose members can be accessed using the class name, rather than a reference to a particular object of that class. The following is a simple example of their use:

 

class SomeClass {

println(sc2.id)

println(SomeClass.objectsCreated)

 

{{out}}

=={{header|Logo}}==

Traditional Logo has dynamic scope for all symbols except for parameters, ostensibly so that it is easy to inspect bound values in an educational setting. UCB Logo also has a LOCAL syntax for declaring a dynamically scoped variable visible to a procedure and those procedures it calls.

make "g 5 ; global

 

localmake "h 5 ; hides global :h within this procedure and those it calls

end

 

=={{header|Logtalk}}==

Logtalk supports scope modifiers in predicate declarations and entity (object, category, or protocol) relations. By default, predicates are local (i.e. like private but invisible to the reflection mechanisms) and entity relations are public (i.e. not change to inherited predicate declarations is applied).

:- public(foo/1). % predicate can be called from anywhere

 

:- protocol(extended, % no change to the scope of the predicates inherited from the extended protocol

extends(public::minimal)).

 

=={{header|M2000 Interpreter}}==

We have to use <= to assign new values to global variables, or to member of groups inside a module inside a group. See ResetValues in Group Alfa.

 

Module Checkit {

M=1000

Modules ? ' list of modules show two: A and A.Checkit

Print Module$ ' print A

Subs are searched first time for current module/function, or from parent code, and stored in a list as name, internal number of code source and position in code. Modules can replaced (we sy decorated) with other modules, before call (see CheckThis changed for a call with ChangeOther).

 

Threads are part of modules/functions. They have own stack of values. own static variables, but they see everything like code in module:

 

Module CheckIt {

Module CheckSub {

}

Call Alfa

 

Block -> localize values of variables (dynamic scoping)

Module creates new symbols:

Module[{x}, Print[x];

Module[{x}, Print[x]]

]

->x$119

->x$120

Block localizes values only; it does not create new symbols:

x = 7;

Block[{x=0}, Print[x]]

Print[x]

->0

 

=={{header|MUMPS}}==

MUMPS variable can be in a local scope if they are declared as NEW within a subroutine. Otherwise variables are accessible to all levels.

SET OUT=1,IN=0

WRITE "OUT = ",OUT,!

WRITE "IN (inner scope) = ",IN,!

KILL OUT

Execution:<pre>

USER>D ^SCOPE

=={{header|Nim}}==

Identifiers annotated with a <code>*</code> are accessible from other modules

proc bar* = echo "bar" # acessible

 

type MyObject = object

name*: string # accessible

 

=={{header|PARI/GP}}==

Pascal does not have scope modifiers.

Regular block scopes are defined simply by virtue of the declaration’s position:

var

f: boolean;

begin

// here, `c`, `f`, and `x`, as well as,

 

=={{header|Perl}}==

There are four kinds of declaration that can influence the scoping of a particular variable: <code>our</code>, <code>my</code>, <code>state</code>, and <code>local</code>. <code>our</code> makes a package variable lexically available. Its primary use is to allow easy access to package variables under stricture.

 

$x = 1; # Compilation error.

our $y = 2;

our $z = 3;

package Bar;

 

<code>my</code> creates a new lexical variable, independent of any package. It's destroyed as soon as it falls out of scope, and each execution of the statement containing the <code>my</code> creates a new, independent variable.

 

my $fruit = 'apple';

package Bar;

our $fruit = 'orange';

print "$fruit\n"; # Prints "orange"; refers to $Bar::fruit.

 

<code>state</code> is like <code>my</code> but creates a variable only once. The variable's value is remembered between visits to the enclosing scope. The <code>state</code> feature is only available in perl 5.9.4 and later, and must be activated with <code>use feature 'state';</code> or a <code>use</code> demanding a sufficiently recent perl.

 

 

sub count_up

 

count_up; # Prints "13".

 

<code>local</code> gives a package variable a new value for the duration of the current ''dynamic'' scope.

 

 

sub phooey

 

do_phooey; # Prints "alpaca".

 

Usually, <code>my</code> is preferable to <code>local</code>, but one thing <code>local</code> can do that <code>my</code> can't is affect the special punctuation variables, like <code>$/</code> and <code>$"</code>. Actually, in perl 5.9.1 and later, <code>my $_</code> is specially allowed and works as you would expect.

 

=={{header|Phix}}==

 

 

Here, localf() can only be invoked from within the same file, but globalf() can be invoked from any other file

that (directly or indirectly) includes it. The global keyword is equally applicable to routines, variables, and constants.

 

Namespaces for specific (entire) files can be used to qualify global identifiers, should there be a name clash between several files.

 

Note however that one of the main reasons for namespaces is to avoid having to amend any included (3rd party)

files, so having namespaces within the file itself may prove to be less than helpful, should they (the namespaces

in and out of scope in every single source file throughout the application. What this means is that if file

a includes b includes c, you can refer in a to c via the namespace of b, but not directly, unless you also

 

The compiler maintains a list of files it has processed; re-inclusion (by some other file) just adds any

=={{header|PowerShell}}==

Variables can have a specific scope, which is one of '''global''', '''local''', '''script''', '''private'''. Variables with the same name can exist in different scopes and are shadowed by child scopes. The scope of a variable can be directly prefixed to the variable name:

function test {

$a = "bar" # local scope

Write-Host Local: $a # "bar" - local variable

Write-Host Global: $global:a # "foo" - global variable

The various cmdlets dealing with variables also have a '''–Scope''' parameter, enabling one to specify a relative or absolute scope for the variable to be manipulated.

 

 

* If a variable is not explicitly defined its scope is local to one of the aforementioned areas. This may be modified by using one of the keywords: <tt>Global</tt>, <tt>Protected</tt>, or <tt>Shared</tt>. The effects are detailed by the comments in the sample code.

baseAge.i = 10

;explicitly define local strings

Input()

CloseConsole()

{{out}}

<pre>Bob and Susan are 30 and 35 years old.

In the example below the name <code>x</code> is defined at various scopes and given a different value dependent on its scope. The innermost functions demonstrate how the scope modifiers give acccess to the name from different scopes:

 

>>> def outerfunc():

x = "From scope at outerfunc"

scoped_global scope gives x = From global scope

scoped_notdefinedlocally scope gives x = From global scope

More information on the scope modifiers can be found [http://docs.python.org/3.0/reference/simple_stmts.html#grammar-token-global_stmt here].

 

up the chain of parent environments.

 

f <- function() {

x <- "local x"

}

f() #prints "local x"

 

attach() will attach an environment or data set to the chain of

enclosing environments.

 

attach(d)

b - a #success

detach(d)

 

Assignment using <- or -> by default happens in the local

definition is found.

 

print(x) #"global x"

 

})

print(x) #"twice modified global x"

 

However, the scope and other aspects of evaluation can be

function.

 

f <- function() {

cat("Lexically enclosed x: ", x,"\n")

x <- "local x"

f()

 

A function's arguments are not evaluated until needed; the function

defined by its first argument, enclosed within the current scope.

 

also <- c(1, 0, 2)

with(d, mean(b - a + also)) #returns 4

eval(substitute(expr), envir=env)

}

 

=={{header|Racket}}==

(formerly Perl 6)

Raku has a system of declarators that introduce new names into various scopes.

our $package-variable;

state $persistent-lexical;

Lexically scoped variables, declared with <tt>my</tt>, are the norm.

Function definitions are intrinsically lexical by default, but allow for forward references, unlike any other declaration.

 

In Perl 5, dynamic scoping is done via "local" to temporarily change the value of a global variable. This mechanism is still specced for Raku, albeit with a different keyword, <tt>temp</tt>, that better reflects what it's doing. None of the implementations yet implement <tt>temp</tt>, since Raku does dynamic scoping via a more robust system of scanning up the call stack for the innermost dynamic declaration, which actually lives in the lexical scope of the function declaring it. We distinguish dynamic variables syntactically by introducing a "twigil" after the sigil. The twigil for dynamic variables is <tt>*</tt> to represent that we don't know how to qualify the location of the variable.

my $*dyn = 'a';

c();

}

a(); # says a

The standard IO filehandles are dynamic variables $*IN, $*OUT, and $*ERR, which allows a program to easily redirect the input or output from any subroutine and all its children. More generally, since most process-wide variables are accessed via this mechanism, and only look in the PROCESS package as a last resort, any chunk of code can pretend to be in a different kind of process environment merely by redefining one or more of the dynamic variables in question, such as %*ENV.

 

 

If more than one identical label is specified, only the first label is recognized (and it isn't considered an error).

a=1/4

b=20

ewe = 'female sheep'

d = 55555555

 

===version 2 scope is DYNAMIC===

b=2

c=3

Say 'in s sigl a b c' sigl a b c

x=4

{{out}}

When s is called from p, it can only see the variable b that is exposed by p.

A protected method is available within a class and available to instances of the same class.<br>

By default, methods are public. Use like this:

#public methods here

private

#private methods

Ruby is an open language. Declaring methods private prevents inadvertend use of methods not meant to be used outside a class. However it is easy to circumvent with metaprogramming methods like <code>instance_eval</code>.

 

In Tcl procedures, variables are local to the procedure unless explicitly declared otherwise (unless they contain namespace separators, which forces interpretation as namespace-scoped names). Declarations may be used to access variables in the global namespace, or the current namespace, or indeed any other namespace.

{{works with|Tcl|8.5}}

namespace eval nsA {

variable varInA "This is a variable in nsA"

nsB::showOff varInA

nsB::showOff varInB

{{out}}

<pre>variable globalVar holds "This is a global variable"

 

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

# Note that this is otherwise syntactically the same as a local variable

variable objVar

}

}

{{out}}

<pre>variable objVar holds "This is an object variable"</pre>

 

To demonstrate these capabilities, here is an example of how we can create a <code>decr</code> command that is just like the <code>incr</code> command except for working with increments in the opposite direction.

upvar 1 $varName var

incr var [expr {-$decrement}]

Here is a kind of version of <code>eval</code> that concatenates its arguments with a semicolon first, instead of the default behavior (a space):

uplevel 1 [join $args ";"]

Of course, these capabilities are designed to be used together. Here is a command that will run a loop over a variable between two bounds, executing a "block" for each step.

upvar 1 $varName var

for {set var $from} {$var <= $to} {incr var} {

}

}

which prints:

<pre>x is now 1

The only scope modifier in TI-89 BASIC is the <code>Local</code> command, which makes the variable local to the enclosing program or function rather than global (in some folder).

 

2 → x

 

=={{header|TXR}}==

Illustration using named blocks. In the first example, the block succeeds and so its binding passes on:

 

@ (block foo)

@ (bind a "a")

@ (accept foo)

@(end)

 

Result (with <code>-B</code> option to dump bindings):

By contrast, in this version, the block fails. Because it is contained in a <code>@(maybe)</code>, evaluation can proceed, but the binding for <code>a</code> is gone.

 

@ (block foo)

@ (bind a "a")

@ (fail foo)

@(end)

 

Result (with <code>-B</code>):

be switched on and off throughout a source text, and only the symbols

declared when they're on will become visible library entry points.

hidden_variable = 3

 

#library-

 

By default, every symbol is visible to every other within the same

file, and multiple declarations of the same symbol are an error, but the

scopes within a single file. In this example, the symbol <code>x</code> will have

a value of 1,

 

#hide+

#hide-

 

but it will be 2 in this example, where

the <code>#export</code> directive selectively allows an otherwise

hidden declaration to be visible outside its enclosing

scope, and allows name clashes to be resolved by proximity.

 

#hide+

#hide-

 

The <code>#hide</code> directives can be arbitrarily nested in matched pairs

to create block structured scope, but doing so is likely to be

declaration. However, this behavior can be overridden using

the dash operator as shown.

 

cat = 3

Here, <code>std-cat</code> refers to the concatenation function from the standard

library, not the locally declared constant by that name.

 

=={{header|zkl}}==