Scope modifiers: Difference between revisions

===Public and private declarative parts===

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}}==

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].<br>

=={{header|R}}==

R uses lexical scoping &ndash; there is a nice introduction to this in the [http://cran.r-project.org/doc/FAQ/R-FAQ.html#Lexical-scoping FAQ on R]. There are no keywords related to scoping, but the [http://stat.ethz.ch/R-manual/R-patched/library/base/html/assign.html assign] function allows you to choose the environment in which a variable is assigned. The global assignment operators , '<<-' and '->>' are effectively shorthand for 'assign(..., envir=globalenv()).

foo <- function()

{

print(x) # "reassigned global value"

}

=={{header|Tcl}}==

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|Ursala}}==

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 x will have

a value of 1,

#hide+

#hide-

but it will be 2 in this example, where

the #export 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 #hide 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, std-cat refers to the concatenation function from the standard

library, not the locally declared constant by that name.