
	Where results make sense

Topic: Lexical scoping

Related Topics

Common Lisp

Static typing

C programming language

Liskov substitution principle

In the News (Sun 20 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	Static scoping
		In lexical scoping, gimmex was defined in the scope of the outer let*, where x is 5.
		Lexical scoping was first introduced in Algol, and has been picked up in other languages since then.
		C and Pascal have always had lexical scoping, since they are both influenced by the ideas that went into Algol.
	www.xasa.com /wiki/en/wikipedia/s/st/static_scoping.html (342 words)

	Scope (programming) - Wikipedia, the free encyclopedia
		A namespace is a scope that uses the enclosing nature of the scope to group logically related identifiers under a single identifier.
		Correct implementation of static scope in languages with first-class nested functions can be subtle, as it requires each function value to carry with it a record of the values of the variables that it depends on (the pair of the function and this environment is called a closure).
		Lexical scoping was first introduced in Lisp 1.5 (via the FUNARG device developed by Steve Russell, working under John McCarthy) and added later into Algol 60 (also by Steve Russell), and has been picked up in other languages since then.
	en.wikipedia.org /wiki/Lexical_scoping (1227 words)

	Static scoping
		In computer science, static scoping, as opposed to dynamic scoping, is a way that the scope of certain variables is determined according to its position in program code.
		This allows programmers to guarantee that their private variables will not accidentally be accessed or altered by functions that they call, and is considered a significant improvement over the older dynamic variable scoping.
		For instance in Lisp, Emacs Lisp uses dynamic scoping (1), Common Lisp has both dynamic and lexical scoping, and Scheme uses lexical scoping exclusively.
	www.ebroadcast.com.au /lookup/encyclopedia/le/Lexical_variable_scoping.html (240 words)

	pop11 help lexical
		Lexical identifiers are sometimes known as "static" and non-lexical ones as "dynamic".
		-- Lexical identifiers have a textually defined scope ----------------- Lexically scoped identifiers are declared within a portion of text that defines their scope, and are accessible only by procedures defined within that portion of text, known as the "scope" of the variable.
		endlblock to define lexical blocks ---------------- In a complex procedure it is sometimes convenient to define a portion of the procedure as providing the scope of a lexical declaration so as to ensure that use of a variable in one part of the procedure will not interact with its use elsewhere.
	www.rdg.ac.uk:8081 /cgi-bin/cgiwrap/wsi14/poplog/pop11/help/lexical (922 words)

	Guile Reference Manual
		This subsection takes a brief diversion to explain what lexical scope means in general and to present an example of non-lexical scoping.
		In practice, lexical scoping is the norm for most programming languages, and probably corresponds to what you would intuitively consider to be "normal".
		To demonstrate that another kind of scoping is possible, therefore, and to compare it against lexical scoping, the following subsection presents an example of non-lexical scoping and examines in detail how its behavior differs from the corresponding lexically scoped code.
	www.delorie.com /gnu/docs/guile/guile_77.html (224 words)

	[Python-Dev] Explicit Lexical Scoping (pre-PEP?)
		Explicitly scoped variables can also be declared at the module level: my x = 1 def f1(): x = 2 # Modifies the global X Declaring a module-level variable with an explicit scope eliminates the need for a 'global' statement for that variable.
		The explicit scope proposal requires that the scope be specified at the place where the variable is defined as opposed to where it is used.
		With explicit scoping, there is no confusion as to which scope is being considered; And explicit scoping allows a single declaration of a variable to be shared by many different inner scopes, which would otherwise require a separate 'outer' statement for each one.
	mail.python.org /pipermail/python-dev/2006-July/066978.html (506 words)

	[No title]
		Lexical scoping should be familiar to anyone who has programmed in Java, C, Perl, or Python since they all provide lexically scoped "local" variables.
		Unlike a lexical binding, which can only be referenced by code within the lexical scope of the binding form, a dynamic binding can be referenced by any code that is invoked during the execution of the binding form.\note{The technical term for the interval during which references may be made to a binding is its "extent".
		Lexical variables have lexical scope but "indefinite" extent, meaning they stick around for an indefinite interval, as determined by how long they are needed.
	www.gigamonkeys.com /book/apress-files/2395ch062d.txt (4464 words)

	lua-users wiki: Lua Scoping Discussion
		Lexical scoping will become the default in 2.2 and is already an option in 2.1 [2].
		Python's implementation of lexical scoping does not allow rebinding of variables from inside a nested function, which is similar to Lua's upvalues.
		In a statically nested scoped language, the scope of an identifier is fixed at compile-time to be the smallest block (begin/end or function/procedure body) containing the identifier's declaration.
	www.lua-users.org /wiki/LuaScopingDiscussion (1587 words)

	Lexical Scoping
		Compilers for these languages typically use quite a different symbol-table structure; each lexical scope creates a new symbol table, and nested lexical scopes are represented as a SpaghettiStack of these tables (a structure constructed by pushing and popping, in which the popped frames remain in place and refer to the parent frames).
		The nested stack of lexical bindings that may be constructed by the compiler internally is something other than a symbol table; it's known as an "environment"---a context object that establishes a mapping from symbols to various entities.
		True lexical variables can be stored in stack frames that support reentrancy in a trivial way, and can be placed in memory location or optimized into registers such that the symbols which refer to them in the source code completely go away upon compilation.
	c2.com /cgi/wiki?LexicalScoping (1295 words)

	Lexical scoping Article, Lexicalscoping Information (Site not responding. Last check: 2007-10-31)
		In computer science, static scoping, as opposedto dynamic scoping, is a way that the scope (programming) of free variables is determined according toits position in program code.
		In dynamic scoping, gimmex would return 10, because when gimmex was called, x was defined to be10.
		C and Pascal have always had lexical scoping, sincethey are both influenced by the ideas that went into Algol.
	www.anoca.org /gimmex/dynamic/lexical_scoping.html (365 words)

	Static scoping - The Jiggies Reference Guide (Site not responding. Last check: 2007-10-31)
		In computer science, static scoping, as opposed to dynamic scoping, is a way that the scope of free variables is determined according to its position in program code.
		For instance in Lisp, Emacs Lisp once used only dynamic scoping, Common Lisp has both dynamic and lexical scoping, and Scheme uses lexical scoping exclusively.
		C and Pascal have always had lexical scoping, which is natural since they are both influenced by the ideas that went into Algol.
	www.jiggies.com /reference/Lexical_variable_scoping (382 words)

	Star Sapphire Common LISP Reference Manual--Scope and Extent
		Lexical scoping is basically a way of defining variables which take on values only while execution is occuring in a given context.
		Lexical scoping is the default mechanism for establishing values for variables in Common LISP.
		Lexical scope means that references to the established entity can occur only within the establishing construct.
	www.webweasel.com /lisp/doc/cl03.htm (2083 words)

	static scoping - Article and Reference from OnPedia.com
		This allows programmers to guarantee that their private variables will not accidentally be accessed or altered by functions that they call, and is considered a significant improvement over the older dynamic variable scoping For example, take this procedure in Scheme:
		gimmex will return 5 in lexical scoping, as Scheme will return, and 10 in dynamic scoping.
		In other cases, languages which already had dynamic scoping have added lexical scoping afterwards, such as Perl.
	www.onpedia.com /encyclopedia/static-scoping (338 words)

	XEmacs Lisp Reference Manual - Variable Scoping (Site not responding. Last check: 2007-10-31)
		Scope refers to where textually in the source code the binding can be accessed.
		By contrast, most programming languages use lexical scoping, in which references to a local variable must be located textually within the function or block that binds the variable.
		Scope: Scope means where in the program a value is visible.
	www.tau.ac.il /cc/pages/docs/xemacs/lispref_169.html (220 words)

	The Mathematica Book Online: Principles of Mathematica \| Modularity and the Naming of Things
		Most traditional computer languages use a so-called "lexical scoping" mechanism for variables, which is analogous to the module mechanism in Mathematica.
		When lexical scoping is used, variables are treated as local to a particular section of the code in a program.
		In dynamic scoping, the values of variables are local to a part of the execution history of the program.
	documents.wolfram.com /mathematica/book/section-2.7.7 (334 words)

	Javascript Closures (Site not responding. Last check: 2007-10-31)
		Because the scope chain is a chain of objects this checking encompasses the prototype chain of that object (if it has one).
		The object identified in the scope chain as having the corresponding property takes the place of the object in the property accessor and the identifier acts as a property name for that object.
		Scope resolution in the execution context of calls to the inner function will resolve identifiers that correspond with named properties of that Activation/Variable object as properties of that object.
	jibbering.com /faq/faq_notes/closures.html (6630 words)

	Dr. Dobb's \| Scoping: Letting Perl Do the Work for You \| April 14, 2004
		This is because within the narrower lexical block, we've declared and defined a new $var, which means that whatever we do to or with $var, in that lexical block, the $var existing at a broader scope is unaffected.
		A closure is a situation where a lexical scope has closed and a reference to a sub defined within that scope is passed to the outside world.
		Lexical scoping can and should be used to constrain a variable to the narrowest useful scope.
	www.ddj.com /dept/lightlang/184416145 (2439 words)

	Info: (elisp) Scope
		(list x)) In a lexically scoped language, the binding of `x' in `binder' would never be accessible in `user', because `user' is not textually contained within the function `binder'.
		Emacs Lisp uses dynamic scoping because simple implementations of lexical scoping are slow.
		In addition, every Lisp system needs to offer dynamic scoping at least as an option; if lexical scoping is the norm, there must be a way to specify dynamic scoping instead for a particular variable.
	www.cims.nyu.edu /cgi-comment/info2html?(elisp)Scope (235 words)

	PEP 227 -- Statically Nested Scopes
		The changed scoping rules address two problems -- the limited utility of lambda expressions (and nested functions in general), and the frequent confusion of new users familiar with other languages that support nested lexical scopes, e.g.
		A cell variable is referenced by containing scopes; as a result, the function where it is defined must allocate separate storage for it on each invocation.
		Third, the use of nested scopes, particularly where a function that access an enclosing scope is returned, should not prevent unreferenced objects from being reclaimed by the garbage collector.
	www.python.org /dev/peps/pep-0227 (2854 words)

	lexical scope from FOLDOC (Site not responding. Last check: 2007-10-31)
		This contrasts with dynamic scope where the scope depends on the nesting of procedure and function calls at run time.
		Statically scoped languages differ as to whether the scope is limited to the smallest block (including begin/end blocks) containing the identifier's declaration (e.g.
		The former is known as static nested scope.
	ftp.sunet.se /foldoc/foldoc.cgi?lexical+scoping (130 words)

	2.7.7 Method Lookup and Lexical Scoping
		The interaction between lexical scoping and inheritance becomes even more significant in the presence of modules as described in section 5.
		We call this "porous" lexical scoping of methods, since the enclosing scope filters through into the nested scope.
		When performing method lookup for a message within some nested scope, the set of methods under consideration are those declared in the current scope plus any methods defined in lexically-enclosing scopes.
	www.cs.washington.edu /research/projects/cecil/cecil/www/Vortex-Three-Zero/doc-cecil-lang/cecil-spec-47.html (506 words)

	Variables
		Lexically scoped variables can be referred to only by code that's textually within the binding form.
		Lexically scoped bindings help keep code understandable by limiting the scope, literally, in which a given name has meaning.
		Unlike a lexical binding, which can be referenced by code only within the lexical scope of the binding form, a dynamic binding can be referenced by any code that's invoked during the execution of the binding form.
	www.gigamonkeys.com /book/variables.html (4760 words)

	[Dev] Python dynamic vs lexical scoping (Site not responding. Last check: 2007-10-31)
		It appears the author is confused by the special way the top-level namespace is handled (in almost every lexically scoped language).
		Lexical scoping without nesting means that a function's globals are determined statically rather than dynamically.
		If globals were determined dynamically, you'd pick up bindings from the module that called the function rather than the module that defined the function.
	lists.osafoundation.org /pipermail/dev/2002-November/000302.html (229 words)

	lexical scoping - a Whatis.com definition
		Lexical scoping (sometimes known as static scoping) is a convention used with many programming languages that sets the scope (range of functionality) of a variable so that it may only be called (referenced) from within the block of code in which it is defined.
		The scope is determined when the code is compiled.
		Dynamic scoping creates variables that can be called from outside the block of code in which they are defined.
	searchnetworking.techtarget.com /gDefinition/0,294236,sid44_gci295434,00.html (207 words)

	Dynamic scoping
		Dynamic variable scoping is when you scope a variable in a programming language by replacing the existing variable of that name with a new variable temporarily, for instance for the duration of a function call.
		However the problem is that if one function calls another, the other may accidentally modify the first function's variables when it intended to modify a global variable instead.
		Therefore over time it is becoming more common for programming languages to implement private variables with lexical variable scoping instead.
	www.xasa.com /wiki/en/wikipedia/d/dy/dynamic_scoping.html (207 words)

	Dynamic Scoping
		In lexical scoping (and if you're the interpreter), you search in the local function (the function which is running now), then you search in the function (or scope) in which that function was defined, then you search in the function (scope) in which that function was defined, and so forth.
		In dynamic scoping, by contrast, you search in the local function first, then you search in the function that called the local function, then you search in the function that called that function, and so on, up the call stack.
		Dynamic scoping is useful as a substitute for globally scoped variables.
	c2.com /cgi/wiki?DynamicScoping (965 words)

Try your search on: Qwika (all wikis)