The namespace command lets you create, access, and destroy separate contexts for commands and variables. See the section WHAT IS A NAMESPACE? below for a brief overview of namespaces. The legal option's are listed below. Note that you can abbreviate the option's.
A namespace is a collection of commands and variables. It encapsulates the commands and variables to ensure that they won't interfere with the commands and variables of other namespaces. Tcl has always had one such collection, which we refer to as the global namespace. The global namespace holds all global variables and commands. The namespace eval command lets you create new namespaces. For example,
creates a new namespace containing the variable num and the procedure Bump. The commands and variables in this namespace are separate from other commands and variables in the same program. If there is a command named Bump in the global namespace, for example, it will be different from the command Bump in the Counter namespace.namespace eval Counter { namespace export Bump variable num 0 proc Bump {} { variable num incr num } }
Namespace variables resemble global variables in Tcl. They exist outside of the procedures in a namespace but can be accessed in a procedure via the variable command, as shown in the example above.
Namespaces are dynamic. You can add and delete commands and variables at any time, so you can build up the contents of a namespace over time using a series of namespace eval commands. For example, the following series of commands has the same effect as the namespace definition shown above:
Note that the test procedure is added to the Counter namespace, and later removed via the rename command.namespace eval Counter { variable num 0 proc Bump {} { variable num return [incr num] } } namespace eval Counter { proc test {args} { return $args } } namespace eval Counter { rename test "" }
Namespaces can have other namespaces within them, so they nest hierarchically. A nested namespace is encapsulated inside its parent namespace and can not interfere with other namespaces.
Each namespace has a textual name such as history or ::safe::interp. Since namespaces may nest, qualified names are used to refer to commands, variables, and child namespaces contained inside namespaces. Qualified names are similar to the hierarchical path names for Unix files or Tk widgets, except that :: is used as the separator instead of / or .. The topmost or global namespace has the name ``'' (i.e., an empty string), although :: is a synonym. As an example, the name ::safe::interp::create refers to the command create in the namespace interp that is a child of of namespace ::safe, which in turn is a child of the global namespace ::.
If you want to access commands and variables from another namespace, you must use some extra syntax. Names must be qualified by the namespace that contains them. From the global namespace, we might access the Counter procedures like this:
We could access the current count like this:Counter::Bump 5 Counter::Reset
When one namespace contains another, you may need more than one qualifier to reach its elements. If we had a namespace Foo that contained the namespace Counter, you could invoke its Bump procedure from the global namespace like this:puts "count = $Counter::num"
Foo::Counter::Bump 3
You can also use qualified names when you create and rename commands. For example, you could add a procedure to the Foo namespace like this:
And you could move the same procedure to another namespace like this:proc Foo::Test {args} {return $args}
rename Foo::Test Bar::Test
There are a few remaining points about qualified names that we should cover. Namespaces have nonempty names except for the global namespace. :: is disallowed in simple command, variable, and namespace names except as a namespace separator. Extra :s in a qualified name are ignored; that is, two or more :s are treated as a namespace separator. A trailing :: in a qualified variable or command name refers to the variable or command named {}. However, a trailing :: in a qualified namespace name is ignored.
In general, all Tcl commands that take variable and command names support qualified names. This means you can give qualified names to such commands as set, proc, rename, and interp alias. If you provide a fully-qualified name that starts with a ::, there is no question about what command, variable, or namespace you mean. However, if the name does not start with a :: (i.e., is relative), Tcl follows a fixed rule for looking it up: Command and variable names are always resolved by looking first in the current namespace, and then in the global namespace. Namespace names, on the other hand, are always resolved by looking in only the current namespace.
In the following example,
Tcl looks for traceLevel in the namespace Debug and then in the global namespace. It looks up the command printTrace in the same way. If a variable or command name is not found in either context, the name is undefined. To make this point absolutely clear, consider the following example:set traceLevel 0 namespace eval Debug { printTrace $traceLevel }
Here Tcl looks for traceLevel first in the namespace Foo::Debug. Since it is not found there, Tcl then looks for it in the global namespace. The variable Foo::traceLevel is completely ignored during the name resolution process.set traceLevel 0 namespace eval Foo { variable traceLevel 3 namespace eval Debug { printTrace $traceLevel } }
You can use the namespace which command to clear up any question about name resolution. For example, the command:
returns ::traceLevel. On the other hand, the command,namespace eval Foo::Debug {namespace which -variable traceLevel}
returns ::Foo::traceLevel.namespace eval Foo {namespace which -variable traceLevel}
As mentioned above, namespace names are looked up differently than the names of variables and commands. Namespace names are always resolved in the current namespace. This means, for example, that a namespace eval command that creates a new namespace always creates a child of the current namespace unless the new namespace name begins with a ::.
Tcl has no access control to limit what variables, commands, or namespaces you can reference. If you provide a qualified name that resolves to an element by the name resolution rule above, you can access the element.
You can access a namespace variable from a procedure in the same namespace by using the variable command. Much like the global command, this creates a local link to the namespace variable. If necessary, it also creates the variable in the current namespace and initializes it. Note that the global command only creates links to variables in the global namespace. It is not necessary to use a variable command if you always refer to the namespace variable using an appropriate qualified name.
Namespaces are often used to represent libraries. Some library commands are used so frequently that it is a nuisance to type their qualified names. For example, suppose that all of the commands in a package like BLT are contained in a namespace called Blt. Then you might access these commands like this:
If you use the graph and table commands frequently, you may want to access them without the Blt:: prefix. You can do this by importing the commands into the current namespace, like this:Blt::graph .g -background red Blt::table . .g 0,0
This adds all exported commands from the Blt namespace into the current namespace context, so you can write code like this:namespace import Blt::*
The namespace import command only imports commands from a namespace that that namespace exported with a namespace export command.graph .g -background red table . .g 0,0
Importing every command from a namespace is generally a bad idea since you don't know what you will get. It is better to import just the specific commands you need. For example, the command
imports only the graph and table commands into the current context.namespace import Blt::graph Blt::table
If you try to import a command that already exists, you will get an error. This prevents you from importing the same command from two different packages. But from time to time (perhaps when debugging), you may want to get around this restriction. You may want to reissue the namespace import command to pick up new commands that have appeared in a namespace. In that case, you can use the -force option, and existing commands will be silently overwritten:
If for some reason, you want to stop using the imported commands, you can remove them with an namespace forget command, like this:namespace import -force Blt::graph Blt::table
This searches the current namespace for any commands imported from Blt. If it finds any, it removes them. Otherwise, it does nothing. After this, the Blt commands must be accessed with the Blt:: prefix.namespace forget Blt::*
When you delete a command from the exporting namespace like this:
the command is automatically removed from all namespaces that import it.rename Blt::graph ""
The procedures Bump and Reset are exported, so they are included when you import from the Counter namespace, like this:namespace eval Counter { namespace export Bump Reset variable num 0 variable max 100 proc Bump {{by 1}} { variable num incr num $by check return $num } proc Reset {} { variable num set num 0 } proc check {} { variable num variable max if {$num > $max} { error "too high!" } } }
However, the check procedure is not exported, so it is ignored by the import operation.namespace import Counter::*
The namespace import command only imports commands that were declared as exported by their namespace. The namespace export command specifies what commands may be imported by other namespaces. If a namespace import command specifies a command that is not exported, the command is not imported.
Copyright © 1989-1994 The Regents of the University of California. Copyright © 1994-1996 Sun Microsystems, Inc.