Namespace

Naming system

A name in a namespace consists of a namespace name and a local name. The namespace name is usually applied as a prefix to the local name.

In augmented Backus–Naur form:

<span id="mwkQ"></span><span class="nc" id="mwkg">name</span><span class="w" id="mwkw"> </span><span class="o" id="mwlA">=</span><span class="w" id="mwlQ"> </span><<span class="nc" id="mwlg">namespace</span><span class="w" id="mwlw"> </span><span class="nc" id="mwmA">name</span>><span class="w" id="mwmQ"> </span><span class="nc" id="mwmg">separator</span><span class="w" id="mwmw"> </span><<span class="nc" id="mwnA">local</span><span class="w" id="mwnQ"> </span><span class="nc" id="mwng">name</span>>

When local names are used by themselves, name resolution is used to decide which (if any) particular name is alluded to by some particular local name.

Examples

Delegation

Delegation of responsibilities between parties is important in real-world applications, such as the structure of the World Wide Web. Namespaces allow delegation of identifier assignment to multiple name issuing organisations whilst retaining global uniqueness. A central Registration authority registers the assigned namespace names allocated. Each namespace name is allocated to an organisation which is subsequently responsible for the assignment of names in their allocated namespace. This organisation may be a name issuing organisation that assign the names themselves, or another Registration authority which further delegates parts of their namespace to different organisations.

Hierarchy

A naming scheme that allows subdelegation of namespaces to third parties is a hierarchical namespace.

A hierarchy is recursive if the syntax for the namespace names is the same for each subdelegation. An example of a recursive hierarchy is the Domain name system.

An example of a non-recursive hierarchy are Uniform Resource Name representing an Internet Assigned Numbers Authority (IANA) number.

Namespace versus scope

A namespace name may provide context (scope in computer science) to a name, and the terms are sometimes used interchangeably. However, the context of a name may also be provided by other factors, such as the location where it occurs or the syntax of the name.

In programming languages

For many programming languages, namespace is a context for their identifiers. In an operating system, an example of namespace is a directory. Each name in a directory uniquely identifies one file or subdirectory.

As a rule, names in a namespace cannot have more than one meaning; that is, different meanings cannot share the same name in the same namespace. A namespace is also called a context, because the same name in different namespaces can have different meanings, each one appropriate for its namespace.

Following are other characteristics of namespaces:

• Names in the namespace can represent objects as well as concepts, be the namespace a natural or ethnic language, a constructed language, the technical terminology of a profession, a dialect, a sociolect, or an artificial language (e.g., a programming language).
• In the Java programming language, identifiers that appear in namespaces have a short (local) name and a unique long "qualified" name for use outside the namespace.
• Some compilers (for languages such as C++) combine namespaces and names for internal use in the compiler in a process called name mangling.

As well as its abstract language technical usage as described above, some languages have a specific keyword used for explicit namespace control, amongst other uses. Below is an example of a namespace in C++:

<span id="mwAhE"></span><span class="k" id="mwAhI">import</span><span class="w" id="mwAhM"> </span><span class="n" id="mwAhQ">std</span><span class="p" id="mwAhU">;</span> <span class="c1" id="mwAhY">// This is how one brings a name into the current scope. In this case, it's</span> <span class="c1" id="mwAhc">// bringing them into global scope.</span> <span class="k" id="mwAhg">using</span><span class="w" id="mwAhk"> </span><span class="n" id="mwAho">std</span><span class="o" id="mwAhs">::</span><span class="n" id="mwAhw">println</span><span class="p" id="mwAh0">;</span> <span class="k" id="mwAh4">namespace</span><span class="w" id="mwAh8"> </span><span class="nn" id="mwAiA">box1</span><span class="w" id="mwAiE"> </span><span class="p" id="mwAiI">{</span> <span class="w" id="mwAiM"> </span><span class="k" id="mwAiQ">constexpr</span><span class="w" id="mwAiU"> </span><span class="kt" id="mwAiY">int</span><span class="w" id="mwAic"> </span><span class="n" id="mwAig">BOX_SIDE</span><span class="w" id="mwAik"> </span><span class="o" id="mwAio">=</span><span class="w" id="mwAis"> </span><span class="mi" id="mwAiw">4</span><span class="p" id="mwAi0">;</span> <span class="p" id="mwAi4">}</span> <span class="k" id="mwAi8">namespace</span><span class="w" id="mwAjA"> </span><span class="nn" id="mwAjE">box2</span><span class="w" id="mwAjI"> </span><span class="p" id="mwAjM">{</span> <span class="w" id="mwAjQ"> </span><span class="k" id="mwAjU">constexpr</span><span class="w" id="mwAjY"> </span><span class="kt" id="mwAjc">int</span><span class="w" id="mwAjg"> </span><span class="n" id="mwAjk">BOX_SIDE</span><span class="w" id="mwAjo"> </span><span class="o" id="mwAjs">=</span><span class="w" id="mwAjw"> </span><span class="mi" id="mwAj0">12</span><span class="p" id="mwAj4">;</span> <span class="p" id="mwAj8">}</span> <span class="kt" id="mwAkA">int</span><span class="w" id="mwAkE"> </span><span class="nf" id="mwAkI">main</span><span class="p" id="mwAkM">()</span><span class="w" id="mwAkQ"> </span><span class="p" id="mwAkU">{</span> <span class="w" id="mwAkY"> </span><span class="k" id="mwAkc">constexpr</span><span class="w" id="mwAkg"> </span><span class="kt" id="mwAkk">int</span><span class="w" id="mwAko"> </span><span class="n" id="mwAks">BOX_SIDE</span><span class="w" id="mwAkw"> </span><span class="o" id="mwAk0">=</span><span class="w" id="mwAk4"> </span><span class="mi" id="mwAk8">42</span><span class="p" id="mwAlA">;</span> <span class="w" id="mwAlE"> </span><span class="n" id="mwAlI">println</span><span class="p" id="mwAlM">(</span><span class="s" id="mwAlQ">"{}"</span><span class="p" id="mwAlU">,</span><span class="w" id="mwAlY"> </span><span class="n" id="mwAlc">box1</span><span class="o" id="mwAlg">::</span><span class="n" id="mwAlk">BOX_SIDE</span><span class="p" id="mwAlo">);</span><span class="w" id="mwAls"> </span><span class="c1" id="mwAlw">// Outputs 4.</span> <span class="w" id="mwAl0"> </span><span class="n" id="mwAl4">println</span><span class="p" id="mwAl8">(</span><span class="s" id="mwAmA">"{}"</span><span class="p" id="mwAmE">,</span><span class="w" id="mwAmI"> </span><span class="n" id="mwAmM">box2</span><span class="o" id="mwAmQ">::</span><span class="n" id="mwAmU">BOX_SIDE</span><span class="p" id="mwAmY">);</span><span class="w" id="mwAmc"> </span><span class="c1" id="mwAmg">// Outputs 12.</span> <span class="w" id="mwAmk"> </span><span class="n" id="mwAmo">println</span><span class="p" id="mwAms">(</span><span class="s" id="mwAmw">"{}"</span><span class="p" id="mwAm0">,</span><span class="w" id="mwAm4"> </span><span class="n" id="mwAm8">BOX_SIDE</span><span class="p" id="mwAnA">);</span><span class="w" id="mwAnE"> </span><span class="c1" id="mwAnI">// Outputs 42.</span> <span class="p" id="mwAnM">}</span>

Computer-science considerations

A namespace in computer science (sometimes also called a name scope) is an abstract container or environment created to hold a logical grouping of unique identifiers or symbols (i.e. names). An identifier defined in a namespace is associated only with that namespace. The same identifier can be independently defined in multiple namespaces. That is, an identifier defined in one namespace may or may not have the same meaning as the same identifier defined in another namespace. Languages that support namespaces specify the rules that determine to which namespace an identifier (not its definition) belongs.

This concept can be illustrated with an analogy. Imagine that two companies, X and Y, each assign ID numbers to their employees. X should not have two employees with the same ID number, and likewise for Y; but it is not a problem for the same ID number to be used at both companies. For example, if Bill works for company X and Jane works for company Y, then it is not a problem for each of them to be employee #123. In this analogy, the ID number is the identifier, and the company serves as the namespace. It does not cause problems for the same identifier to identify a different person in each namespace.

In large computer programs or documents it is common to have hundreds or thousands of identifiers. Namespaces (or a similar technique, see Emulating namespaces) provide a mechanism for hiding local identifiers. They provide a means of grouping logically related identifiers into corresponding namespaces, thereby making the system more modular.

Data storage devices and many modern programming languages support namespaces. Storage devices use directories (or folders) as namespaces. This allows two files with the same name to be stored on the device so long as they are stored in different directories. In some programming languages (e.g. C++, Python), the identifiers naming namespaces are themselves associated with an enclosing namespace. Thus, in these languages namespaces can nest, forming a namespace tree. At the root of this tree is the unnamed global namespace.

Use in common languages

C

In C, although the language does not formally have namespaces (though they are frequently emulated), identifiers may be thought of as inhabiting different namespaces; that being ordinary identifiers, tags (struct/union/enum), member names, and labels. For instance, the name Foo may be reused in these four contexts:

<span id="mwApc"></span><span class="cp" id="mwApg">#include</span><span class="w" id="mwApk"> </span><span class="cpf" id="mwApo"><stdio.h></span> <span class="c1" id="mwAps">// in the tag namespace</span> <span class="k" id="mwApw">struct</span><span class="w" id="mwAp0"> </span><span class="nc" id="mwAp4">Foo</span><span class="w" id="mwAp8"> </span><span class="p" id="mwAqA">{</span> <span class="w" id="mwAqE"> </span><span class="kt" id="mwAqI">int</span><span class="w" id="mwAqM"> </span><span class="n" id="mwAqQ">Foo</span><span class="p" id="mwAqU">;</span><span class="w" id="mwAqY"> </span><span class="c1" id="mwAqc">// in the member namespace</span> <span class="p" id="mwAqg">};</span> <span class="c1" id="mwAqk">// function name and parameter (ordinary identifiers)</span> <span class="k" id="mwAqo">struct</span><span class="w" id="mwAqs"> </span><span class="nc" id="mwAqw">Foo</span><span class="w" id="mwAq0"> </span><span class="n" id="mwAq4">Foo</span><span class="p" id="mwAq8">(</span><span class="kt" id="mwArA">int</span><span class="w" id="mwArE"> </span><span class="n" id="mwArI">Foo</span><span class="p" id="mwArM">)</span><span class="w" id="mwArQ"> </span><span class="p" id="mwArU">{</span> <span class="w" id="mwArY"> </span><span class="k" id="mwArc">struct</span><span class="w" id="mwArg"> </span><span class="nc" id="mwArk">Foo</span><span class="w" id="mwAro"> </span><span class="n" id="mwArs">result</span><span class="w" id="mwArw"> </span><span class="o" id="mwAr0">=</span><span class="w" id="mwAr4"> </span><span class="p" id="mwAr8">{</span><span class="w" id="mwAsA"> </span><span class="p" id="mwAsE">.</span><span class="n" id="mwAsI">Foo</span><span class="w" id="mwAsM"> </span><span class="o" id="mwAsQ">=</span><span class="w" id="mwAsU"> </span><span class="n" id="mwAsY">Foo</span><span class="w" id="mwAsc"> </span><span class="p" id="mwAsg">};</span> <span class="w" id="mwAsk"> </span><span class="k" id="mwAso">if</span><span class="w" id="mwAss"> </span><span class="p" id="mwAsw">(</span><span class="n" id="mwAs0">Foo</span><span class="w" id="mwAs4"> </span><span class="o" id="mwAs8"><</span><span class="w" id="mwAtA"> </span><span class="mi" id="mwAtE">0</span><span class="p" id="mwAtI">)</span><span class="w" id="mwAtM"> </span><span class="p" id="mwAtQ">{</span> <span class="w" id="mwAtU"> </span><span class="k" id="mwAtY">goto</span><span class="w" id="mwAtc"> </span><span class="n" id="mwAtg">Foo</span><span class="p" id="mwAtk">;</span><span class="w" id="mwAto"> </span><span class="c1" id="mwAts">// in the label namespace</span> <span class="w" id="mwAtw"> </span><span class="p" id="mwAt0">}</span> <span class="w" id="mwAt4"> </span><span class="k" id="mwAt8">return</span><span class="w" id="mwAuA"> </span><span class="n" id="mwAuE">result</span><span class="p" id="mwAuI">;</span> <span class="nl" id="mwAuM">Foo</span><span class="p" id="mwAuQ">:</span> <span class="w" id="mwAuU"> </span><span class="n" id="mwAuY">result</span><span class="p" id="mwAuc">.</span><span class="n" id="mwAug">Foo</span><span class="w" id="mwAuk"> </span><span class="o" id="mwAuo">=</span><span class="w" id="mwAus"> </span><span class="mi" id="mwAuw">0</span><span class="p" id="mwAu0">;</span> <span class="w" id="mwAu4"> </span><span class="k" id="mwAu8">return</span><span class="w" id="mwAvA"> </span><span class="n" id="mwAvE">result</span><span class="p" id="mwAvI">;</span> <span class="p" id="mwAvM">}</span> <span class="kt" id="mwAvQ">int</span><span class="w" id="mwAvU"> </span><span class="n" id="mwAvY">main</span><span class="p" id="mwAvc">()</span><span class="w" id="mwAvg"> </span><span class="p" id="mwAvk">{</span> <span class="w" id="mwAvo"> </span><span class="c1" id="mwAvs">// creates a struct Foo, named Foo,</span> <span class="w" id="mwAvw"> </span><span class="c1" id="mwAv0">// using the function Foo()</span> <span class="w" id="mwAv4"> </span><span class="k" id="mwAv8">struct</span><span class="w" id="mwAwA"> </span><span class="nc" id="mwAwE">Foo</span><span class="w" id="mwAwI"> </span><span class="n" id="mwAwM">Foo</span><span class="w" id="mwAwQ"> </span><span class="o" id="mwAwU">=</span><span class="w" id="mwAwY"> </span><span class="n" id="mwAwc">Foo</span><span class="p" id="mwAwg">(</span><span class="mi" id="mwAwk">42</span><span class="p" id="mwAwo">);</span> <span class="w" id="mwAws"> </span><span class="n" id="mwAww">printf</span><span class="p" id="mwAw0">(</span><span class="s" id="mwAw4">"%d</span><span class="se" id="mwAw8">\n</span><span class="s" id="mwAxA">"</span><span class="p" id="mwAxE">,</span><span class="w" id="mwAxI"> </span><span class="n" id="mwAxM">Foo</span><span class="p" id="mwAxQ">.</span><span class="n" id="mwAxU">Foo</span><span class="p" id="mwAxY">);</span> <span class="p" id="mwAxc">}</span>

Additionally, it is possible to use anonymous structs as namespaces in C since C99.

Math.h:

<span id="mwAx8"></span><span class="cp" id="mwAyA">#pragma once</span> <span class="k" id="mwAyE">struct</span><span class="w" id="mwAyI"> </span><span class="nc" id="mwAyM">StatsNamespace</span><span class="w" id="mwAyQ"> </span><span class="p" id="mwAyU">{</span> <span class="w" id="mwAyY"> </span><span class="kt" id="mwAyc">double</span><span class="w" id="mwAyg"> </span><span class="p" id="mwAyk">(</span><span class="o" id="mwAyo">*</span><span class="n" id="mwAys">mean</span><span class="p" id="mwAyw">)(</span><span class="k" id="mwAy0">const</span><span class="w" id="mwAy4"> </span><span class="kt" id="mwAy8">double</span><span class="o" id="mwAzA">*</span><span class="p" id="mwAzE">,</span><span class="w" id="mwAzI"> </span><span class="kt" id="mwAzM">size_t</span><span class="p" id="mwAzQ">);</span> <span class="w" id="mwAzU"> </span><span class="kt" id="mwAzY">double</span><span class="w" id="mwAzc"> </span><span class="p" id="mwAzg">(</span><span class="o" id="mwAzk">*</span><span class="n" id="mwAzo">median</span><span class="p" id="mwAzs">)(</span><span class="k" id="mwAzw">const</span><span class="w" id="mwAz0"> </span><span class="kt" id="mwAz4">double</span><span class="o" id="mwAz8">*</span><span class="p" id="mwA0A">,</span><span class="w" id="mwA0E"> </span><span class="kt" id="mwA0I">size_t</span><span class="p" id="mwA0M">);</span> <span class="w" id="mwA0Q"> </span><span class="c1" id="mwA0U">// more functions...</span> <span class="p" id="mwA0Y">}</span> <span class="k" id="mwA0c">struct</span><span class="w" id="mwA0g"> </span><span class="nc" id="mwA0k">MathNamespace</span><span class="w" id="mwA0o"> </span><span class="p" id="mwA0s">{</span> <span class="w" id="mwA0w"> </span><span class="kt" id="mwA00">double</span><span class="w" id="mwA04"> </span><span class="n" id="mwA08">PI</span><span class="p" id="mwA1A">;</span> <span class="w" id="mwA1E"> </span><span class="kt" id="mwA1I">double</span><span class="w" id="mwA1M"> </span><span class="n" id="mwA1Q">E</span><span class="p" id="mwA1U">;</span> <span class="w" id="mwA1Y"> </span><span class="kt" id="mwA1c">double</span><span class="w" id="mwA1g"> </span><span class="p" id="mwA1k">(</span><span class="o" id="mwA1o">*</span><span class="n" id="mwA1s">sin</span><span class="p" id="mwA1w">)(</span><span class="kt" id="mwA10">double</span><span class="p" id="mwA14">);</span> <span class="w" id="mwA18"> </span><span class="c1" id="mwA2A">// more functions...</span> <span class="w" id="mwA2E"> </span><span class="c1" id="mwA2I">// a "nested namespace"</span> <span class="w" id="mwA2M"> </span><span class="k" id="mwA2Q">struct</span><span class="w" id="mwA2U"> </span><span class="nc" id="mwA2Y">StatsNamespace</span><span class="w" id="mwA2c"> </span><span class="n" id="mwA2g">Stats</span><span class="p" id="mwA2k">;</span> <span class="p" id="mwA2o">};</span> <span class="k" id="mwA2s">extern</span><span class="w" id="mwA2w"> </span><span class="k" id="mwA20">const</span><span class="w" id="mwA24"> </span><span class="k" id="mwA28">struct</span><span class="w" id="mwA3A"> </span><span class="nc" id="mwA3E">MathNamespace</span><span class="w" id="mwA3I"> </span><span class="n" id="mwA3M">Math</span><span class="p" id="mwA3Q">;</span>

Math.c:

<span id="mwA3o"></span><span class="cp" id="mwA3s">#include</span><span class="w" id="mwA3w"> </span><span class="cpf" id="mwA30"><math.h></span> <span class="cp" id="mwA34">#include</span><span class="w" id="mwA38"> </span><span class="cpf" id="mwA4A">"Math.h"</span> <span class="k" id="mwA4E">static</span><span class="w" id="mwA4I"> </span><span class="kt" id="mwA4M">double</span><span class="w" id="mwA4Q"> </span><span class="nf" id="mwA4U">_sin</span><span class="p" id="mwA4Y">(</span><span class="kt" id="mwA4c">double</span><span class="w" id="mwA4g"> </span><span class="n" id="mwA4k">arg</span><span class="p" id="mwA4o">)</span><span class="w" id="mwA4s"> </span><span class="p" id="mwA4w">{</span> <span class="w" id="mwA40"> </span><span class="k" id="mwA44">return</span><span class="w" id="mwA48"> </span><span class="n" id="mwA5A">sin</span><span class="p" id="mwA5E">(</span><span class="n" id="mwA5I">arg</span><span class="p" id="mwA5M">);</span> <span class="p" id="mwA5Q">}</span> <span class="k" id="mwA5U">static</span><span class="w" id="mwA5Y"> </span><span class="kt" id="mwA5c">double</span><span class="w" id="mwA5g"> </span><span class="nf" id="mwA5k">_mean</span><span class="p" id="mwA5o">(</span><span class="k" id="mwA5s">const</span><span class="w" id="mwA5w"> </span><span class="kt" id="mwA50">double</span><span class="o" id="mwA54">*</span><span class="w" id="mwA58"> </span><span class="n" id="mwA6A">data</span><span class="p" id="mwA6E">,</span><span class="w" id="mwA6I"> </span><span class="kt" id="mwA6M">size_t</span><span class="w" id="mwA6Q"> </span><span class="n" id="mwA6U">size</span><span class="p" id="mwA6Y">)</span><span class="w" id="mwA6c"> </span><span class="p" id="mwA6g">{</span> <span class="w" id="mwA6k"> </span><span class="c1" id="mwA6o">// ...</span> <span class="p" id="mwA6s">}</span> <span class="k" id="mwA6w">static</span><span class="w" id="mwA60"> </span><span class="kt" id="mwA64">double</span><span class="w" id="mwA68"> </span><span class="nf" id="mwA7A">_median</span><span class="p" id="mwA7E">(</span><span class="k" id="mwA7I">const</span><span class="w" id="mwA7M"> </span><span class="kt" id="mwA7Q">double</span><span class="o" id="mwA7U">*</span><span class="w" id="mwA7Y"> </span><span class="n" id="mwA7c">data</span><span class="p" id="mwA7g">,</span><span class="w" id="mwA7k"> </span><span class="kt" id="mwA7o">size_t</span><span class="w" id="mwA7s"> </span><span class="n" id="mwA7w">size</span><span class="p" id="mwA70">)</span><span class="w" id="mwA74"> </span><span class="p" id="mwA78">{</span> <span class="w" id="mwA8A"> </span><span class="c1" id="mwA8E">// ...</span> <span class="p" id="mwA8I">}</span> <span class="k" id="mwA8M">const</span><span class="w" id="mwA8Q"> </span><span class="k" id="mwA8U">struct</span><span class="w" id="mwA8Y"> </span><span class="nc" id="mwA8c">MathNamespace</span><span class="w" id="mwA8g"> </span><span class="n" id="mwA8k">Math</span><span class="w" id="mwA8o"> </span><span class="o" id="mwA8s">=</span><span class="w" id="mwA8w"> </span><span class="p" id="mwA80">{</span> <span class="w" id="mwA84"> </span><span class="p" id="mwA88">.</span><span class="n" id="mwA9A">PI</span><span class="w" id="mwA9E"> </span><span class="o" id="mwA9I">=</span><span class="w" id="mwA9M"> </span><span class="n" id="mwA9Q">M_PI</span><span class="p" id="mwA9U">,</span> <span class="w" id="mwA9Y"> </span><span class="p" id="mwA9c">.</span><span class="n" id="mwA9g">E</span><span class="w" id="mwA9k"> </span><span class="o" id="mwA9o">=</span><span class="w" id="mwA9s"> </span><span class="n" id="mwA9w">M_E</span><span class="p" id="mwA90">,</span> <span class="w" id="mwA94"> </span><span class="p" id="mwA98">.</span><span class="n" id="mwA-A">sin</span><span class="w" id="mwA-E"> </span><span class="o" id="mwA-I">=</span><span class="w" id="mwA-M"> </span><span class="n" id="mwA-Q">_sin</span><span class="p" id="mwA-U">,</span> <span class="w" id="mwA-Y"> </span><span class="c1" id="mwA-c">// ...</span> <span class="w" id="mwA-g"> </span><span class="p" id="mwA-k">.</span><span class="n" id="mwA-o">Stats</span><span class="w" id="mwA-s"> </span><span class="o" id="mwA-w">=</span><span class="w" id="mwA-0"> </span><span class="p" id="mwA-4">{</span> <span class="w" id="mwA-8"> </span><span class="p" id="mwA_A">.</span><span class="n" id="mwA_E">mean</span><span class="w" id="mwA_I"> </span><span class="o" id="mwA_M">=</span><span class="w" id="mwA_Q"> </span><span class="n" id="mwA_U">_mean</span><span class="p" id="mwA_Y">,</span> <span class="w" id="mwA_c"> </span><span class="p" id="mwA_g">.</span><span class="n" id="mwA_k">median</span><span class="w" id="mwA_o"> </span><span class="o" id="mwA_s">=</span><span class="w" id="mwA_w"> </span><span class="n" id="mwA_0">_median</span><span class="p" id="mwA_4">,</span> <span class="w" id="mwA_8"> </span><span class="c1" id="mwBAA">// ...</span> <span class="w" id="mwBAE"> </span><span class="p" id="mwBAI">}</span> <span class="p" id="mwBAM">};</span>

Main.c:

<span id="mwBAk"></span><span class="cp" id="mwBAo">#include</span><span class="w" id="mwBAs"> </span><span class="cpf" id="mwBAw"><stdio.h></span> <span class="cp" id="mwBA0">#include</span><span class="w" id="mwBA4"> </span><span class="cpf" id="mwBA8">"Math.h"</span> <span class="kt" id="mwBBA">int</span><span class="w" id="mwBBE"> </span><span class="nf" id="mwBBI">main</span><span class="p" id="mwBBM">()</span><span class="w" id="mwBBQ"> </span><span class="p" id="mwBBU">{</span> <span class="w" id="mwBBY"> </span><span class="kt" id="mwBBc">double</span><span class="w" id="mwBBg"> </span><span class="n" id="mwBBk">dataset</span><span class="p" id="mwBBo">[]</span><span class="w" id="mwBBs"> </span><span class="o" id="mwBBw">=</span><span class="w" id="mwBB0"> </span><span class="p" id="mwBB4">{</span><span class="mf" id="mwBB8">1.0</span><span class="p" id="mwBCA">,</span><span class="w" id="mwBCE"> </span><span class="mf" id="mwBCI">2.0</span><span class="p" id="mwBCM">,</span><span class="w" id="mwBCQ"> </span><span class="mf" id="mwBCU">3.0</span><span class="p" id="mwBCY">,</span><span class="w" id="mwBCc"> </span><span class="mf" id="mwBCg">4.0</span><span class="p" id="mwBCk">,</span><span class="w" id="mwBCo"> </span><span class="mf" id="mwBCs">5.0</span><span class="p" id="mwBCw">};</span> <span class="w" id="mwBC0"> </span><span class="n" id="mwBC4">printf</span><span class="p" id="mwBC8">(</span><span class="s" id="mwBDA">"sin(0) = %d</span><span class="se" id="mwBDE">\n</span><span class="s" id="mwBDI">"</span><span class="p" id="mwBDM">,</span><span class="w" id="mwBDQ"> </span><span class="n" id="mwBDU">Math</span><span class="p" id="mwBDY">.</span><span class="n" id="mwBDc">sin</span><span class="p" id="mwBDg">(</span><span class="mi" id="mwBDk">0</span><span class="p" id="mwBDo">));</span> <span class="w" id="mwBDs"> </span><span class="n" id="mwBDw">printf</span><span class="p" id="mwBD0">(</span><span class="s" id="mwBD4">"pi is %f</span><span class="se" id="mwBD8">\n</span><span class="s" id="mwBEA">"</span><span class="p" id="mwBEE">,</span><span class="w" id="mwBEI"> </span><span class="n" id="mwBEM">Math</span><span class="p" id="mwBEQ">.</span><span class="n" id="mwBEU">PI</span><span class="p" id="mwBEY">);</span> <span class="w" id="mwBEc"> </span><span class="n" id="mwBEg">printf</span><span class="p" id="mwBEk">(</span><span class="s" id="mwBEo">"Average: %f</span><span class="se" id="mwBEs">\n</span><span class="s" id="mwBEw">"</span><span class="p" id="mwBE0">,</span><span class="w" id="mwBE4"> </span><span class="n" id="mwBE8">Math</span><span class="p" id="mwBFA">.</span><span class="n" id="mwBFE">Stats</span><span class="p" id="mwBFI">.</span><span class="n" id="mwBFM">mean</span><span class="p" id="mwBFQ">(</span><span class="n" id="mwBFU">dataset</span><span class="p" id="mwBFY">,</span><span class="w" id="mwBFc"> </span><span class="k" id="mwBFg">sizeof</span><span class="p" id="mwBFk">(</span><span class="n" id="mwBFo">dataset</span><span class="p" id="mwBFs">)</span><span class="w" id="mwBFw"> </span><span class="o" id="mwBF0">/</span><span class="w" id="mwBF4"> </span><span class="k" id="mwBF8">sizeof</span><span class="p" id="mwBGA">(</span><span class="kt" id="mwBGE">double</span><span class="p" id="mwBGI">)));</span> <span class="p" id="mwBGM">}</span>

C++

In C++, a namespace is defined with a namespace block.

<span id="mwBG0"></span><span class="k" id="mwBG4">namespace</span><span class="w" id="mwBG8"> </span><span class="nn" id="mwBHA">abc</span><span class="w" id="mwBHE"> </span><span class="p" id="mwBHI">{</span> <span class="w" id="mwBHM"> </span><span class="kt" id="mwBHQ">int</span><span class="w" id="mwBHU"> </span><span class="n" id="mwBHY">bar</span><span class="p" id="mwBHc">;</span> <span class="p" id="mwBHg">}</span>

Within this block, identifiers can be used exactly as they are declared. Outside of this block, the namespace specifier must be prefixed. For example, outside of namespace abc, bar must be written abc::bar to be accessed. C++ includes another construct that makes this verbosity unnecessary. By adding the line

<span id="mwBII"></span><span class="k" id="mwBIM">using</span><span class="w" id="mwBIQ"> </span><span class="k" id="mwBIU">namespace</span><span class="w" id="mwBIY"> </span><span class="nn" id="mwBIc">abc</span><span class="p" id="mwBIg">;</span>

to a piece of code, the prefix abc:: is no longer needed.

Identifiers that are not explicitly declared within a namespace are considered to be in the global namespace.

<span id="mwBI4"></span><span class="kt" id="mwBI8">int</span><span class="w" id="mwBJA"> </span><span class="n" id="mwBJE">foo</span><span class="p" id="mwBJI">;</span>

These identifiers can be used exactly as they are declared, or, since the global namespace is unnamed, the namespace specifier :: can be prefixed. For example, foo can also be written ::foo.

Namespace resolution in C++ is hierarchical. This means that within the hypothetical namespace food::soup, the identifier Chicken refers to food::soup::Chicken. If food::soup::Chicken doesn't exist, it then refers to food::Chicken. If neither food::soup::Chicken nor food::Chicken exist, Chicken refers to ::Chicken, an identifier in the global namespace.

Namespaces in C++ are most often used to avoid naming collisions. Although namespaces are used extensively in recent C++ code, most older code does not use this facility because it did not exist in early versions of the language. For example, the entire C++ Standard Library is defined within namespace std, but before standardization many components were originally in the global namespace. The using statement can be used to import a symbol into the current scope.

The use of the using statements in headers for reasons other than backwards compatibility (e.g., convenience) is considered to be against good code practices, as those using statements propagate into all translation units that include the header. However, modules do not export using statements unless explicitly marked export, making using statements safer to use. For instance, one can import a module wikipedia.project.util with matching namespace wikipedia::project::util and then use using statements on symbols from that namespace to simplify verbose namespaces. Unlike other languages like Java or Rust, C++ modules, namespaces and source file structure do not necessarily match, though it is convention to match them for clarity (for example, module foo.bar.baz.Qux matches namespaced class foo::bar::baz::Qux and resides in file foo/bar/baz/Qux.cppm).

using should be used to simplify verbose nested namespaces when modular translation units are used.

<span id="mwBME"></span><span class="k" id="mwBMI">export</span><span class="w" id="mwBMM"> </span><span class="k" id="mwBMQ">module</span><span class="w" id="mwBMU"> </span><span class="n" id="mwBMY">wikipedia</span><span class="p" id="mwBMc">.</span><span class="n" id="mwBMg">project</span><span class="p" id="mwBMk">.</span><span class="n" id="mwBMo">App</span><span class="p" id="mwBMs">;</span> <span class="k" id="mwBMw">import</span><span class="w" id="mwBM0"> </span><span class="n" id="mwBM4">std</span><span class="p" id="mwBM8">;</span> <span class="k" id="mwBNA">import</span><span class="w" id="mwBNE"> </span><span class="n" id="mwBNI">wikipedia</span><span class="p" id="mwBNM">.</span><span class="n" id="mwBNQ">project</span><span class="p" id="mwBNU">.</span><span class="n" id="mwBNY">fs</span><span class="p" id="mwBNc">;</span> <span class="k" id="mwBNg">import</span><span class="w" id="mwBNk"> </span><span class="n" id="mwBNo">wikipedia</span><span class="p" id="mwBNs">.</span><span class="n" id="mwBNw">project</span><span class="p" id="mwBN0">.</span><span class="n" id="mwBN4">util</span><span class="p" id="mwBN8">;</span> <span class="k" id="mwBOA">using</span><span class="w" id="mwBOE"> </span><span class="n" id="mwBOI">wikipedia</span><span class="o" id="mwBOM">::</span><span class="n" id="mwBOQ">project</span><span class="o" id="mwBOU">::</span><span class="n" id="mwBOY">fs</span><span class="o" id="mwBOc">::</span><span class="n" id="mwBOg">File</span><span class="p" id="mwBOk">;</span> <span class="k" id="mwBOo">using</span><span class="w" id="mwBOs"> </span><span class="n" id="mwBOw">wikipedia</span><span class="o" id="mwBO0">::</span><span class="n" id="mwBO4">project</span><span class="o" id="mwBO8">::</span><span class="n" id="mwBPA">util</span><span class="o" id="mwBPE">::</span><span class="n" id="mwBPI">ConfigLoader</span><span class="p" id="mwBPM">;</span> <span class="k" id="mwBPQ">using</span><span class="w" id="mwBPU"> </span><span class="n" id="mwBPY">wikipedia</span><span class="o" id="mwBPc">::</span><span class="n" id="mwBPg">project</span><span class="o" id="mwBPk">::</span><span class="n" id="mwBPo">util</span><span class="o" id="mwBPs">::</span><span class="n" id="mwBPw">logging</span><span class="o" id="mwBP0">::</span><span class="n" id="mwBP4">Logger</span><span class="p" id="mwBP8">;</span> <span class="k" id="mwBQA">using</span><span class="w" id="mwBQE"> </span><span class="n" id="mwBQI">wikipedia</span><span class="o" id="mwBQM">::</span><span class="n" id="mwBQQ">project</span><span class="o" id="mwBQU">::</span><span class="n" id="mwBQY">util</span><span class="o" id="mwBQc">::</span><span class="n" id="mwBQg">logging</span><span class="o" id="mwBQk">::</span><span class="n" id="mwBQo">LoggerFactory</span><span class="p" id="mwBQs">;</span> <span class="k" id="mwBQw">export</span><span class="w" id="mwBQ0"> </span><span class="k" id="mwBQ4">namespace</span><span class="w" id="mwBQ8"> </span><span class="nn" id="mwBRA">wikipedia</span><span class="o" id="mwBRE">::</span><span class="nn" id="mwBRI">project</span><span class="w" id="mwBRM"> </span><span class="p" id="mwBRQ">{</span> <span class="k" id="mwBRU">class</span><span class="w" id="mwBRY"> </span><span class="nc" id="mwBRc">App</span><span class="w" id="mwBRg"> </span><span class="p" id="mwBRk">{</span> <span class="k" id="mwBRo">private</span><span class="o" id="mwBRs">:</span> <span class="w" id="mwBRw"> </span><span class="n" id="mwBR0">Logger</span><span class="w" id="mwBR4"> </span><span class="n" id="mwBR8">logger</span><span class="p" id="mwBSA">;</span> <span class="w" id="mwBSE"> </span><span class="c1" id="mwBSI">// private fields and methods</span> <span class="k" id="mwBSM">public</span><span class="o" id="mwBSQ">:</span> <span class="w" id="mwBSU"> </span><span class="n" id="mwBSY">App</span><span class="p" id="mwBSc">()</span><span class="o" id="mwBSg">:</span> <span class="w" id="mwBSk"> </span><span class="n" id="mwBSo">logger</span><span class="p" id="mwBSs">{</span><span class="n" id="mwBSw">LoggerFactory</span><span class="o" id="mwBS0">::</span><span class="n" id="mwBS4">getLogger</span><span class="p" id="mwBS8">(</span><span class="s" id="mwBTA">"Main"</span><span class="p" id="mwBTE">)}</span><span class="w" id="mwBTI"> </span><span class="p" id="mwBTM">{</span> <span class="w" id="mwBTQ"> </span><span class="n" id="mwBTU">ConfigLoader</span><span class="w" id="mwBTY"> </span><span class="n" id="mwBTc">cl</span><span class="p" id="mwBTg">(</span><span class="n" id="mwBTk">File</span><span class="p" id="mwBTo">(</span><span class="s" id="mwBTs">"config/config_file.txt"</span><span class="p" id="mwBTw">));</span> <span class="w" id="mwBT0"> </span><span class="n" id="mwBT4">logger</span><span class="p" id="mwBT8">.</span><span class="n" id="mwBUA">log</span><span class="p" id="mwBUE">(</span><span class="s" id="mwBUI">"Application starting..."</span><span class="p" id="mwBUM">);</span> <span class="w" id="mwBUQ"> </span><span class="c1" id="mwBUU">// rest of code</span> <span class="w" id="mwBUY"> </span><span class="p" id="mwBUc">}</span> <span class="p" id="mwBUg">};</span> <span class="p" id="mwBUk">}</span>

C++11 introduces inline namespaces, which is such that its members are treated as if they are also members of the enclosing namespace. It is declared by writing inline namespace. It is akin to an implicit using namespace statement, meaning qualifying symbols in it is optional.

The inline property is transitive. If a namespace a contains an inline namespace b, which in turn contains another inline namespace c, then members of c can be accessed as if they were members of a or b.

A primary use case for inline namespaces is ABI compatibility and versioning. By placing different versions of an API within distinct inline namespaces (e.g., v1, v2), and then making the currently desired version inline, library developers can manage ABI compatibility. When a new version is released, the inline keyword can be moved to the new version's namespace, allowing users to automatically link against the new version while still enabling access to older versions through explicit qualification.

<span id="mwBWI"></span><span class="k" id="mwBWM">namespace</span><span class="w" id="mwBWQ"> </span><span class="nn" id="mwBWU">mylib</span><span class="o" id="mwBWY">::</span><span class="nn" id="mwBWc">utils</span><span class="w" id="mwBWg"> </span><span class="p" id="mwBWk">{</span> <span class="w" id="mwBWo"> </span><span class="k" id="mwBWs">namespace</span><span class="w" id="mwBWw"> </span><span class="nn" id="mwBW0">v1</span><span class="w" id="mwBW4"> </span><span class="p" id="mwBW8">{</span> <span class="w" id="mwBXA"> </span><span class="p" id="mwBXE">[[</span><span class="na" id="mwBXI">deprecated</span><span class="p" id="mwBXM">(</span><span class="s" id="mwBXQ">"Use mylib::utils::v2::func() instead"</span><span class="p" id="mwBXU">)]]</span> <span class="w" id="mwBXY"> </span><span class="kt" id="mwBXc">void</span><span class="w" id="mwBXg"> </span><span class="n" id="mwBXk">func</span><span class="p" id="mwBXo">()</span><span class="w" id="mwBXs"> </span><span class="p" id="mwBXw">{</span> <span class="w" id="mwBX0"> </span><span class="c1" id="mwBX4">// Old implementation</span> <span class="w" id="mwBX8"> </span><span class="p" id="mwBYA">}</span> <span class="w" id="mwBYE"> </span><span class="p" id="mwBYI">}</span> <span class="w" id="mwBYM"> </span><span class="c1" id="mwBYQ">// v2 is the currently active version</span> <span class="w" id="mwBYU"> </span><span class="kr" id="mwBYY">inline</span><span class="w" id="mwBYc"> </span><span class="k" id="mwBYg">namespace</span><span class="w" id="mwBYk"> </span><span class="nn" id="mwBYo">v2</span><span class="w" id="mwBYs"> </span><span class="p" id="mwBYw">{</span> <span class="w" id="mwBY0"> </span><span class="kt" id="mwBY4">void</span><span class="w" id="mwBY8"> </span><span class="nf" id="mwBZA">func</span><span class="p" id="mwBZE">()</span><span class="w" id="mwBZI"> </span><span class="p" id="mwBZM">{</span> <span class="w" id="mwBZQ"> </span><span class="c1" id="mwBZU">// New implementation</span> <span class="w" id="mwBZY"> </span><span class="p" id="mwBZc">}</span> <span class="w" id="mwBZg"> </span><span class="p" id="mwBZk">}</span> <span class="p" id="mwBZo">}</span> <span class="kt" id="mwBZs">int</span><span class="w" id="mwBZw"> </span><span class="n" id="mwBZ0">main</span><span class="p" id="mwBZ4">()</span><span class="w" id="mwBZ8"> </span><span class="p" id="mwBaA">{</span> <span class="w" id="mwBaE"> </span><span class="c1" id="mwBaI">// Calls mylib::utils::v2::func() implicitly</span> <span class="w" id="mwBaM"> </span><span class="n" id="mwBaQ">mylib</span><span class="o" id="mwBaU">::</span><span class="n" id="mwBaY">utils</span><span class="o" id="mwBac">::</span><span class="n" id="mwBag">func</span><span class="p" id="mwBak">();</span> <span class="w" id="mwBao"> </span><span class="c1" id="mwBas">// Calls mylib::utils::v2::func() explicitly</span> <span class="w" id="mwBaw"> </span><span class="n" id="mwBa0">mylib</span><span class="o" id="mwBa4">::</span><span class="n" id="mwBa8">utils</span><span class="o" id="mwBbA">::</span><span class="n" id="mwBbE">v2</span><span class="o" id="mwBbI">::</span><span class="n" id="mwBbM">func</span><span class="p" id="mwBbQ">();</span> <span class="w" id="mwBbU"> </span><span class="c1" id="mwBbY">// Calls mylib::utils::v1::func() explicitly</span> <span class="w" id="mwBbc"> </span><span class="n" id="mwBbg">mylib</span><span class="o" id="mwBbk">::</span><span class="n" id="mwBbo">utils</span><span class="o" id="mwBbs">::</span><span class="n" id="mwBbw">v1</span><span class="o" id="mwBb0">::</span><span class="n" id="mwBb4">func</span><span class="p" id="mwBb8">();</span> <span class="w" id="mwBcA"> </span><span class="k" id="mwBcE">return</span><span class="w" id="mwBcI"> </span><span class="mi" id="mwBcM">0</span><span class="p" id="mwBcQ">;</span> <span class="p" id="mwBcU">}</span>

C++ additionally allows declaring an "unnamed namespace" (also known as an "anonymous namespace"). All entities placed inside an unnamed namespace are given internal linkage. An unnamed namespace may be placed at any namespace. An unnamed namespace should not be confused for the global namespace.

<span id="mwBco"></span><span class="k" id="mwBcs">namespace</span><span class="w" id="mwBcw"> </span><span class="p" id="mwBc0">{</span> <span class="w" id="mwBc4"> </span><span class="k" id="mwBc8">class</span><span class="w" id="mwBdA"> </span><span class="nc" id="mwBdE">Foo</span><span class="p" id="mwBdI">;</span> <span class="p" id="mwBdM">}</span> <span class="k" id="mwBdQ">namespace</span><span class="w" id="mwBdU"> </span><span class="nn" id="mwBdY">mylib</span><span class="w" id="mwBdc"> </span><span class="p" id="mwBdg">{</span> <span class="w" id="mwBdk"> </span><span class="k" id="mwBdo">namespace</span><span class="w" id="mwBds"> </span><span class="p" id="mwBdw">{</span> <span class="w" id="mwBd0"> </span><span class="kt" id="mwBd4">void</span><span class="w" id="mwBd8"> </span><span class="nf" id="mwBeA">bar</span><span class="p" id="mwBeE">();</span> <span class="w" id="mwBeI"> </span><span class="p" id="mwBeM">}</span> <span class="p" id="mwBeQ">}</span>

C#

Namespaces are heavily used in C# language. All .NET framework classes are organized in namespaces. Namespaces are used by programmers to organize their work and to avoid naming collisions. When referencing a class, one may specify either its fully qualified name, meaning its namespace followed by the class name:

<span id="mwBes"></span><span class="n" id="mwBew">System</span><span class="p" id="mwBe0">.</span><span class="n" id="mwBe4">Console</span><span class="p" id="mwBe8">.</span><span class="n" id="mwBfA">WriteLine</span><span class="p" id="mwBfE">(</span><span class="s" id="mwBfI">"Hello World!"</span><span class="p" id="mwBfM">);</span> <span class="kt" id="mwBfQ">int</span><span class="w" id="mwBfU"> </span><span class="n" id="mwBfY">i</span><span class="w" id="mwBfc"> </span><span class="o" id="mwBfg">=</span><span class="w" id="mwBfk"> </span><span class="n" id="mwBfo">System</span><span class="p" id="mwBfs">.</span><span class="n" id="mwBfw">Convert</span><span class="p" id="mwBf0">.</span><span class="n" id="mwBf4">ToInt32</span><span class="p" id="mwBf8">(</span><span class="s" id="mwBgA">"123"</span><span class="p" id="mwBgE">);</span>

or add a using statement. This eliminates the need to mention the complete name of all classes in that namespace.

<span id="mwBgc"></span><span class="k" id="mwBgg">using</span><span class="w" id="mwBgk"> </span><span class="nn" id="mwBgo">System</span><span class="p" id="mwBgs">;</span> <span class="n" id="mwBgw">Console</span><span class="p" id="mwBg0">.</span><span class="n" id="mwBg4">WriteLine</span><span class="p" id="mwBg8">(</span><span class="s" id="mwBhA">"Hello World!"</span><span class="p" id="mwBhE">);</span> <span class="kt" id="mwBhI">int</span><span class="w" id="mwBhM"> </span><span class="n" id="mwBhQ">i</span><span class="w" id="mwBhU"> </span><span class="o" id="mwBhY">=</span><span class="w" id="mwBhc"> </span><span class="n" id="mwBhg">Convert</span><span class="p" id="mwBhk">.</span><span class="n" id="mwBho">ToInt32</span><span class="p" id="mwBhs">(</span><span class="s" id="mwBhw">"123"</span><span class="p" id="mwBh0">);</span>

In the above examples, System is a namespace, and Console and Convert are classes defined within System.

Unlike C++, using can only import all symbols in a namespace (much like using namespace from C++, use * in Rust, or import * in Java). It cannot be used to import individual symbols and classes like it is used in Java.

<span id="mwBjo"></span><span class="k" id="mwBjs">namespace</span><span class="w" id="mwBjw"> </span><span class="nn" id="mwBj0">Wikipedia.Project</span><span class="p" id="mwBj4">;</span> <span class="k" id="mwBj8">using</span><span class="w" id="mwBkA"> </span><span class="nn" id="mwBkE">System</span><span class="p" id="mwBkI">;</span> <span class="k" id="mwBkM">using</span><span class="w" id="mwBkQ"> </span><span class="nn" id="mwBkU">System.IO</span><span class="p" id="mwBkY">;</span> <span class="k" id="mwBkc">using</span><span class="w" id="mwBkg"> </span><span class="nn" id="mwBkk">Microsoft.Extensions.Logging</span><span class="p" id="mwBko">;</span> <span class="k" id="mwBks">using</span><span class="w" id="mwBkw"> </span><span class="nn" id="mwBk0">Wikipedia.Project.Utility</span><span class="p" id="mwBk4">;</span> <span class="k" id="mwBk8">class</span><span class="w" id="mwBlA"> </span><span class="nc" id="mwBlE">App</span> <span class="p" id="mwBlI">{</span> <span class="w" id="mwBlM"> </span><span class="k" id="mwBlQ">private</span><span class="w" id="mwBlU"> </span><span class="k" id="mwBlY">static</span><span class="w" id="mwBlc"> </span><span class="n" id="mwBlg">ILogger</span><span class="o" id="mwBlk"><</span><span class="n" id="mwBlo">Program</span><span class="o" id="mwBls">></span><span class="w" id="mwBlw"> </span><span class="n" id="mwBl0">logger</span><span class="p" id="mwBl4">;</span> <span class="w" id="mwBl8"> </span><span class="k" id="mwBmA">public</span><span class="w" id="mwBmE"> </span><span class="nf" id="mwBmI">App</span><span class="p" id="mwBmM">()</span> <span class="w" id="mwBmQ"> </span><span class="p" id="mwBmU">{</span> <span class="w" id="mwBmY"> </span><span class="n" id="mwBmc">ConfigLoader</span><span class="w" id="mwBmg"> </span><span class="n" id="mwBmk">cl</span><span class="w" id="mwBmo"> </span><span class="o" id="mwBms">=</span><span class="w" id="mwBmw"> </span><span class="k" id="mwBm0">new</span><span class="w" id="mwBm4"> </span><span class="n" id="mwBm8">ConfigLoader</span><span class="p" id="mwBnA">(</span><span class="n" id="mwBnE">Path</span><span class="p" id="mwBnI">.</span><span class="n" id="mwBnM">Combine</span><span class="p" id="mwBnQ">(</span><span class="s" id="mwBnU">"config"</span><span class="p" id="mwBnY">,</span><span class="w" id="mwBnc"> </span><span class="s" id="mwBng">"config_file.txt"</span><span class="p" id="mwBnk">));</span> <span class="w" id="mwBno"> </span><span class="n" id="mwBns">LoggerFactory</span><span class="w" id="mwBnw"> </span><span class="n" id="mwBn0">loggerFactory</span><span class="w" id="mwBn4"> </span><span class="o" id="mwBn8">=</span><span class="w" id="mwBoA"> </span><span class="n" id="mwBoE">LoggerFactory</span><span class="p" id="mwBoI">.</span><span class="n" id="mwBoM">Create</span><span class="p" id="mwBoQ">(</span><span class="n" id="mwBoU">builder</span><span class="w" id="mwBoY"> </span><span class="o" id="mwBoc">=></span><span class="w" id="mwBog"> </span> <span class="w" id="mwBok"> </span><span class="p" id="mwBoo">{</span> <span class="w" id="mwBos"> </span><span class="n" id="mwBow">builder</span><span class="p" id="mwBo0">.</span><span class="n" id="mwBo4">AddConsole</span><span class="p" id="mwBo8">();</span> <span class="w" id="mwBpA"> </span><span class="p" id="mwBpE">});</span> <span class="w" id="mwBpI"> </span><span class="n" id="mwBpM">logger</span><span class="w" id="mwBpQ"> </span><span class="o" id="mwBpU">=</span><span class="w" id="mwBpY"> </span><span class="n" id="mwBpc">loggerFactory</span><span class="p" id="mwBpg">.</span><span class="n" id="mwBpk">CreateLogger</span><span class="o" id="mwBpo"><</span><span class="n" id="mwBps">Program</span><span class="o" id="mwBpw">></span><span class="p" id="mwBp0">();</span> <span class="w" id="mwBp4"> </span><span class="n" id="mwBp8">logger</span><span class="p" id="mwBqA">.</span><span class="n" id="mwBqE">LogInformation</span><span class="p" id="mwBqI">(</span><span class="s" id="mwBqM">"Application starting..."</span><span class="p" id="mwBqQ">);</span> <span class="w" id="mwBqU"> </span><span class="c1" id="mwBqY">// rest of code</span> <span class="w" id="mwBqc"> </span><span class="p" id="mwBqg">}</span> <span class="p" id="mwBqk">}</span>

Unlike C++, C# namespaces do not allow relative referencing of symbols. For example, the class Foo.Bar.Baz.Qux cannot be referred to as Baz.Qux even if referred to from within namespace Foo.Bar: either the namespace Foo.Bar.Baz must be imported to refer to class Qux, or Foo.Bar.Baz.Qux must be fully qualified.

Java

In Java, the idea of a namespace is embodied in Java packages. All code belongs to a package, although that package need not be explicitly named. Code from other packages is accessed by prefixing the package name before the appropriate identifier, for example class String in package java.lang can be referred to as java.lang.String (this is known as the fully qualified class name). Like C++, Java offers a construct that makes it unnecessary to type the package name (import). However, certain features (such as reflection) require the programmer to use the fully qualified name.

Unlike C++, namespaces in Java are not hierarchical as to the syntax of the language. However, packages are named in a hierarchical manner. For example, all packages beginning with java are a part of the Java platform—the package java.lang contains classes core to the language, and java.lang.reflect contains core classes specifically relating to reflection.

In Java (and Ada, C#, and others), namespaces/packages express semantic categories of code. For example, in C#, namespace System contains code provided by the system (the .NET framework). How specific these categories are and how deep the hierarchies go differ from language to language.

Function and class scopes can be viewed as implicit namespaces that are inextricably linked with visibility, accessibility, and object lifetime.

In Java, packages cannot be partially qualified like they can in C++. For instance, it is not possible to import the java namespace and then refer to java.util.ArrayList as util.ArrayList. Symbols must either be fully qualified or imported completely into scope. import statements are not transitive nor can they be deliberately marked export like in C++. All import statements must appear at the beginning of the file, and cannot be written at any other scope. This is in contrast to C++, where the std namespace can be imported by writing using namespace std;, and then std::chrono::system_clock can be referred to as chrono::system_clock.

<span id="mwBuc"></span><span class="kn" id="mwBug">package</span><span class="w" id="mwBuk"> </span><span class="nn" id="mwBuo">org.wikipedia.project</span><span class="p" id="mwBus">;</span> <span class="kn" id="mwBuw">import</span><span class="w" id="mwBu0"> </span><span class="nn" id="mwBu4">java.nio.file.Paths</span><span class="p" id="mwBu8">;</span> <span class="kn" id="mwBvA">import</span><span class="w" id="mwBvE"> </span><span class="nn" id="mwBvI">java.util.logging.Level</span><span class="p" id="mwBvM">;</span> <span class="kn" id="mwBvQ">import</span><span class="w" id="mwBvU"> </span><span class="nn" id="mwBvY">java.util.logging.Logger</span><span class="p" id="mwBvc">;</span> <span class="kn" id="mwBvg">import</span><span class="w" id="mwBvk"> </span><span class="nn" id="mwBvo">org.wikipdia.project.util.ConfigLoader</span><span class="p" id="mwBvs">;</span> <span class="kd" id="mwBvw">public</span><span class="w" id="mwBv0"> </span><span class="kd" id="mwBv4">class</span> <span class="nc" id="mwBv8">App</span><span class="w" id="mwBwA"> </span><span class="p" id="mwBwE">{</span> <span class="w" id="mwBwI"> </span><span class="kd" id="mwBwM">private</span><span class="w" id="mwBwQ"> </span><span class="kd" id="mwBwU">static</span><span class="w" id="mwBwY"> </span><span class="kd" id="mwBwc">final</span><span class="w" id="mwBwg"> </span><span class="n" id="mwBwk">Logger</span><span class="w" id="mwBwo"> </span><span class="n" id="mwBws">logger</span><span class="w" id="mwBww"> </span><span class="o" id="mwBw0">=</span><span class="w" id="mwBw4"> </span><span class="n" id="mwBw8">Logger</span><span class="p" id="mwBxA">.</span><span class="na" id="mwBxE">getLogger</span><span class="p" id="mwBxI">(</span><span class="n" id="mwBxM">Main</span><span class="p" id="mwBxQ">.</span><span class="na" id="mwBxU">class</span><span class="p" id="mwBxY">.</span><span class="na" id="mwBxc">getName</span><span class="p" id="mwBxg">());</span> <span class="w" id="mwBxk"> </span><span class="kd" id="mwBxo">public</span><span class="w" id="mwBxs"> </span><span class="nf" id="mwBxw">App</span><span class="p" id="mwBx0">()</span><span class="w" id="mwBx4"> </span><span class="p" id="mwBx8">{</span> <span class="w" id="mwByA"> </span><span class="n" id="mwByE">ConfigLoader</span><span class="w" id="mwByI"> </span><span class="n" id="mwByM">cl</span><span class="w" id="mwByQ"> </span><span class="o" id="mwByU">=</span><span class="w" id="mwByY"> </span><span class="k" id="mwByc">new</span><span class="w" id="mwByg"> </span><span class="n" id="mwByk">ConfigLoader</span><span class="p" id="mwByo">(</span><span class="n" id="mwBys">Paths</span><span class="p" id="mwByw">.</span><span class="na" id="mwBy0">get</span><span class="p" id="mwBy4">(</span><span class="s" id="mwBy8">"config/config_file.txt"</span><span class="p" id="mwBzA">));</span> <span class="w" id="mwBzE"> </span><span class="n" id="mwBzI">logger</span><span class="p" id="mwBzM">.</span><span class="na" id="mwBzQ">log</span><span class="p" id="mwBzU">(</span><span class="n" id="mwBzY">Level</span><span class="p" id="mwBzc">.</span><span class="na" id="mwBzg">INFO</span><span class="p" id="mwBzk">,</span><span class="w" id="mwBzo"> </span><span class="s" id="mwBzs">"Application starting..."</span><span class="p" id="mwBzw">);</span> <span class="w" id="mwBz0"> </span><span class="c1" id="mwBz4">// rest of code</span> <span class="w" id="mwBz8"> </span><span class="p" id="mwB0A">}</span> <span class="p" id="mwB0E">}</span>

Because Java does not support independent functions outside of classes, static class methods and so-called "utility classes" (classes with private constructors and all methods and fields static) are the equivalent to C++-style namespaces. Some examples are java.lang.Math, which contains the constants like Math.PI and methods like Math.sin().

import statements can be used to import all symbols in a package, called a wildcard import, which is similar to using namespace in C++. For instance, writing import java.util.*; imports all classes in the java.util package. This however, can cause symbol pollution within a file. Furthermore, using glob import statements on packages that have classes with the same name can cause ambiguity, and will fail to compile. However, java.lang.* is implicitly imported into all Java source files by default.

<span id="mwB1Y"></span><span class="kn" id="mwB1c">import</span><span class="w" id="mwB1g"> </span><span class="nn" id="mwB1k">java.sql.*</span><span class="p" id="mwB1o">;</span><span class="w" id="mwB1s"> </span><span class="c1" id="mwB1w">// Imports all classes in java.sql, including java.sql.Date</span> <span class="kn" id="mwB10">import</span><span class="w" id="mwB14"> </span><span class="nn" id="mwB18">java.util.*</span><span class="p" id="mwB2A">;</span><span class="w" id="mwB2E"> </span><span class="c1" id="mwB2I">// Imports all classes in java.util, including java.util.Date</span> <span class="n" id="mwB2M">Date</span><span class="w" id="mwB2Q"> </span><span class="n" id="mwB2U">d</span><span class="w" id="mwB2Y"> </span><span class="o" id="mwB2c">=</span><span class="w" id="mwB2g"> </span><span class="k" id="mwB2k">new</span><span class="w" id="mwB2o"> </span><span class="n" id="mwB2s">Date</span><span class="p" id="mwB2w">();</span><span class="w" id="mwB20"> </span><span class="c1" id="mwB24">// Ambiguous Date reference resulting in compilation error</span> <span class="c1" id="mwB28">// Instead, the fully-qualified names must be used:</span> <span class="n" id="mwB3A">java</span><span class="p" id="mwB3E">.</span><span class="na" id="mwB3I">sql</span><span class="p" id="mwB3M">.</span><span class="na" id="mwB3Q">Date</span><span class="w" id="mwB3U"> </span><span class="n" id="mwB3Y">sqlDate</span><span class="w" id="mwB3c"> </span><span class="o" id="mwB3g">=</span><span class="w" id="mwB3k"> </span><span class="k" id="mwB3o">new</span><span class="w" id="mwB3s"> </span><span class="n" id="mwB3w">java</span><span class="p" id="mwB30">.</span><span class="na" id="mwB34">sql</span><span class="p" id="mwB38">.</span><span class="na" id="mwB4A">Date</span><span class="p" id="mwB4E">(</span><span class="n" id="mwB4I">System</span><span class="p" id="mwB4M">.</span><span class="na" id="mwB4Q">currentTimeMillis</span><span class="p" id="mwB4U">());</span> <span class="n" id="mwB4Y">java</span><span class="p" id="mwB4c">.</span><span class="na" id="mwB4g">util</span><span class="p" id="mwB4k">.</span><span class="na" id="mwB4o">Date</span><span class="w" id="mwB4s"> </span><span class="n" id="mwB4w">utilDate</span><span class="w" id="mwB40"> </span><span class="o" id="mwB44">=</span><span class="w" id="mwB48"> </span><span class="k" id="mwB5A">new</span><span class="w" id="mwB5E"> </span><span class="n" id="mwB5I">java</span><span class="p" id="mwB5M">.</span><span class="na" id="mwB5Q">util</span><span class="p" id="mwB5U">.</span><span class="na" id="mwB5Y">Date</span><span class="p" id="mwB5c">();</span>

Kotlin

Kotlin packages are very similar to Java packages, but unlike Java where only class-like objects may reside directly in a package, any top-level symbol (such as a variable, class, type alias, etc.) may live directly inside a package.

<span id="mwB50"></span><span class="k" id="mwB54">package</span><span class="w" id="mwB58"> </span><span class="nn" id="mwB6A">org.wikipedia.examples</span> <span class="k" id="mwB6E">import</span><span class="w" id="mwB6I"> </span><span class="nn" id="mwB6M">kotlin.math.PI</span> <span class="kd" id="mwB6Q">var</span><span class="w" id="mwB6U"> </span><span class="nv" id="mwB6Y">myPi</span><span class="w" id="mwB6c"> </span><span class="o" id="mwB6g">=</span><span class="w" id="mwB6k"> </span><span class="n" id="mwB6o">PI</span> <span class="kd" id="mwB6s">fun</span><span class="w" id="mwB6w"> </span><span class="nf" id="mwB60">circleArea</span><span class="p" id="mwB64">(</span><span class="n" id="mwB68">radius</span><span class="p" id="mwB7A">:</span><span class="w" id="mwB7E"> </span><span class="kt" id="mwB7I">Double</span><span class="p" id="mwB7M">):</span><span class="w" id="mwB7Q"> </span><span class="kt" id="mwB7U">Double</span><span class="w" id="mwB7Y"> </span><span class="p" id="mwB7c">{</span> <span class="w" id="mwB7g"> </span><span class="k" id="mwB7k">return</span><span class="w" id="mwB7o"> </span><span class="n" id="mwB7s">myPi</span><span class="w" id="mwB7w"> </span><span class="o" id="mwB70">*</span><span class="w" id="mwB74"> </span><span class="n" id="mwB78">radius</span><span class="w" id="mwB8A"> </span><span class="o" id="mwB8E">*</span><span class="w" id="mwB8I"> </span><span class="n" id="mwB8M">radius</span> <span class="p" id="mwB8Q">}</span>

However, even though Kotlin allows top-level non-class objects to reside directly in a package, this is represented in the Java Virtual Machine internally as residing inside a generated class, resembling something like the following:

<span id="mwB8k"></span><span class="kn" id="mwB8o">package</span><span class="w" id="mwB8s"> </span><span class="nn" id="mwB8w">org.wikipedia.examples</span><span class="p" id="mwB80">;</span> <span class="kd" id="mwB84">public</span><span class="w" id="mwB88"> </span><span class="kd" id="mwB9A">final</span><span class="w" id="mwB9E"> </span><span class="kd" id="mwB9I">class</span> <span class="nc" id="mwB9M">ExampleKt</span><span class="w" id="mwB9Q"> </span><span class="p" id="mwB9U">{</span> <span class="w" id="mwB9Y"> </span><span class="kd" id="mwB9c">private</span><span class="w" id="mwB9g"> </span><span class="kd" id="mwB9k">static</span><span class="w" id="mwB9o"> </span><span class="kt" id="mwB9s">double</span><span class="w" id="mwB9w"> </span><span class="n" id="mwB90">myPi</span><span class="w" id="mwB94"> </span><span class="o" id="mwB98">=</span><span class="w" id="mwB-A"> </span><span class="n" id="mwB-E">Math</span><span class="p" id="mwB-I">.</span><span class="na" id="mwB-M">PI</span><span class="p" id="mwB-Q">;</span> <span class="w" id="mwB-U"> </span><span class="kd" id="mwB-Y">public</span><span class="w" id="mwB-c"> </span><span class="kd" id="mwB-g">static</span><span class="w" id="mwB-k"> </span><span class="kd" id="mwB-o">final</span><span class="w" id="mwB-s"> </span><span class="kt" id="mwB-w">double</span><span class="w" id="mwB-0"> </span><span class="nf" id="mwB-4">getMyPi</span><span class="p" id="mwB-8">()</span><span class="w" id="mwB_A"> </span><span class="p" id="mwB_E">{</span> <span class="w" id="mwB_I"> </span><span class="k" id="mwB_M">return</span><span class="w" id="mwB_Q"> </span><span class="n" id="mwB_U">myPi</span><span class="p" id="mwB_Y">;</span> <span class="w" id="mwB_c"> </span><span class="p" id="mwB_g">}</span> <span class="w" id="mwB_k"> </span><span class="kd" id="mwB_o">public</span><span class="w" id="mwB_s"> </span><span class="kd" id="mwB_w">static</span><span class="w" id="mwB_0"> </span><span class="kd" id="mwB_4">final</span><span class="w" id="mwB_8"> </span><span class="kt" id="mwCAA">void</span><span class="w" id="mwCAE"> </span><span class="nf" id="mwCAI">setMyPi</span><span class="p" id="mwCAM">(</span><span class="kt" id="mwCAQ">double</span><span class="w" id="mwCAU"> </span><span class="n" id="mwCAY">value</span><span class="p" id="mwCAc">)</span><span class="w" id="mwCAg"> </span><span class="p" id="mwCAk">{</span> <span class="w" id="mwCAo"> </span><span class="n" id="mwCAs">myPi</span><span class="w" id="mwCAw"> </span><span class="o" id="mwCA0">=</span><span class="w" id="mwCA4"> </span><span class="n" id="mwCA8">value</span><span class="p" id="mwCBA">;</span> <span class="w" id="mwCBE"> </span><span class="p" id="mwCBI">}</span> <span class="w" id="mwCBM"> </span><span class="kd" id="mwCBQ">public</span><span class="w" id="mwCBU"> </span><span class="kd" id="mwCBY">static</span><span class="w" id="mwCBc"> </span><span class="kd" id="mwCBg">final</span><span class="w" id="mwCBk"> </span><span class="kt" id="mwCBo">double</span><span class="w" id="mwCBs"> </span><span class="nf" id="mwCBw">circleArea</span><span class="p" id="mwCB0">(</span><span class="kt" id="mwCB4">double</span><span class="w" id="mwCB8"> </span><span class="n" id="mwCCA">radius</span><span class="p" id="mwCCE">)</span><span class="w" id="mwCCI"> </span><span class="p" id="mwCCM">{</span> <span class="w" id="mwCCQ"> </span><span class="k" id="mwCCU">return</span><span class="w" id="mwCCY"> </span><span class="n" id="mwCCc">myPi</span><span class="w" id="mwCCg"> </span><span class="o" id="mwCCk">*</span><span class="w" id="mwCCo"> </span><span class="n" id="mwCCs">radius</span><span class="w" id="mwCCw"> </span><span class="o" id="mwCC0">*</span><span class="w" id="mwCC4"> </span><span class="n" id="mwCC8">radius</span><span class="p" id="mwCDA">;</span> <span class="w" id="mwCDE"> </span><span class="p" id="mwCDI">}</span> <span class="p" id="mwCDM">}</span>

PHP

Namespaces were introduced into PHP from version 5.3 onwards. Naming collision of classes, functions and variables can be avoided. In PHP, a namespace is defined with a namespace block.

<span id="mwCDo"></span><span class="c1" id="mwCDs"># File phpstar/foobar.php</span> <span class="k" id="mwCDw">namespace</span> <span class="nx" id="mwCD0">phpstar</span><span class="p" id="mwCD4">;</span> <span class="k" id="mwCD8">class</span> <span class="nc" id="mwCEA">FooBar</span> <span class="p" id="mwCEE">{</span> <span class="k" id="mwCEI">public</span> <span class="k" id="mwCEM">function</span> <span class="nf" id="mwCEQ">foo</span><span class="p" id="mwCEU">()</span><span class="o" id="mwCEY">:</span> <span class="nx" id="mwCEc">void</span> <span class="p" id="mwCEg">{</span> <span class="k" id="mwCEk">echo</span> <span class="s1" id="mwCEo">'Hello world, from function foo'</span><span class="p" id="mwCEs">;</span> <span class="p" id="mwCEw">}</span> <span class="k" id="mwCE0">public</span> <span class="k" id="mwCE4">function</span> <span class="nf" id="mwCE8">bar</span><span class="p" id="mwCFA">()</span><span class="o" id="mwCFE">:</span> <span class="nx" id="mwCFI">void</span> <span class="p" id="mwCFM">{</span> <span class="k" id="mwCFQ">echo</span> <span class="s1" id="mwCFU">'Hello world, from function bar'</span><span class="p" id="mwCFY">;</span> <span class="p" id="mwCFc">}</span> <span class="p" id="mwCFg">}</span>

We can reference a PHP namespace with the following different ways:

<span id="mwCFw"></span><span class="c1" id="mwCF0"># File index.php</span> <span class="c1" id="mwCF4"># Include the file</span> <span class="k" id="mwCF8">include</span> <span class="s2" id="mwCGA">"phpstar/foobar.php"</span><span class="p" id="mwCGE">;</span> <span class="c1" id="mwCGI"># Option 1: directly prefix the class name with the namespace</span> <span class="nv" id="mwCGM">$obj_foobar</span> <span class="o" id="mwCGQ">=</span> <span class="k" id="mwCGU">new</span> <span class="nx" id="mwCGY">\phpstar\FooBar</span><span class="p" id="mwCGc">();</span> <span class="c1" id="mwCGg"># Option 2: import the namespace</span> <span class="k" id="mwCGk">use</span> <span class="nx" id="mwCGo">phpstar\FooBar</span><span class="p" id="mwCGs">;</span> <span class="nv" id="mwCGw">$obj_foobar</span> <span class="o" id="mwCG0">=</span> <span class="k" id="mwCG4">new</span> <span class="nx" id="mwCG8">FooBar</span><span class="p" id="mwCHA">();</span> <span class="c1" id="mwCHE"># Option 2a: import & alias the namespace</span> <span class="k" id="mwCHI">use</span> <span class="nx" id="mwCHM">phpstar\FooBar</span> <span class="k" id="mwCHQ">as</span> <span class="nx" id="mwCHU">FB</span><span class="p" id="mwCHY">;</span> <span class="nv" id="mwCHc">$obj_foobar</span> <span class="o" id="mwCHg">=</span> <span class="k" id="mwCHk">new</span> <span class="nx" id="mwCHo">FB</span><span class="p" id="mwCHs">();</span> <span class="c1" id="mwCHw"># Access the properties and methods with regular way</span> <span class="nv" id="mwCH0">$obj_foobar</span><span class="o" id="mwCH4">-></span><span class="na" id="mwCH8">foo</span><span class="p" id="mwCIA">();</span> <span class="nv" id="mwCIE">$obj_foobar</span><span class="o" id="mwCII">-></span><span class="na" id="mwCIM">bar</span><span class="p" id="mwCIQ">();</span>

Python

In Python, namespaces are defined by the individual modules, and since modules can be contained in hierarchical packages, then namespaces are hierarchical too. In general when a module is imported then the names defined in the module are defined via that module's namespace, and are accessed in from the calling modules by using the fully qualified name.

<span id="mwCJY"></span><span class="c1" id="mwCJc"># assume mod_a defines two functions : func1() and func2() and one class : Class1</span> <span class="kn" id="mwCJg">import</span><span class="w" id="mwCJk"> </span><span class="nn" id="mwCJo">mod_a</span> <span class="n" id="mwCJs">mod_a</span><span class="o" id="mwCJw">.</span><span class="n" id="mwCJ0">func1</span><span class="p" id="mwCJ4">()</span> <span class="n" id="mwCJ8">mod_a</span><span class="o" id="mwCKA">.</span><span class="n" id="mwCKE">func2</span><span class="p" id="mwCKI">()</span> <span class="n" id="mwCKM">a</span><span class="p" id="mwCKQ">:</span> <span class="n" id="mwCKU">mod_a</span><span class="o" id="mwCKY">.</span><span class="n" id="mwCKc">Class1</span> <span class="o" id="mwCKg">=</span> <span class="n" id="mwCKk">mod_a</span><span class="o" id="mwCKo">.</span><span class="n" id="mwCKs">Class1</span><span class="p" id="mwCKw">()</span>

The from ... import ... statement can be used to insert the relevant names directly into the calling module's namespace, and those names can be accessed from the calling module without the qualified name:

<span id="mwCLc"></span><span class="c1" id="mwCLg"># assume mod_a defines two functions : func1() and func2() and one class : Class1</span> <span class="kn" id="mwCLk">from</span><span class="w" id="mwCLo"> </span><span class="nn" id="mwCLs">mod_a</span><span class="w" id="mwCLw"> </span><span class="kn" id="mwCL0">import</span> <span class="n" id="mwCL4">func1</span> <span class="n" id="mwCL8">func1</span><span class="p" id="mwCMA">()</span> <span class="n" id="mwCME">func2</span><span class="p" id="mwCMI">()</span> <span class="c1" id="mwCMM"># this will fail as an undefined name, as will the full name mod_a.func2()</span> <span class="n" id="mwCMQ">a</span><span class="p" id="mwCMU">:</span> <span class="n" id="mwCMY">Class1</span> <span class="o" id="mwCMc">=</span> <span class="n" id="mwCMg">Class1</span><span class="p" id="mwCMk">()</span> <span class="c1" id="mwCMo"># this will fail as an undefined name, as will the full name mod_a.Class1()</span>

Since this directly imports names (without qualification) it can overwrite existing names with no warnings.

A special form of the statement is from ... import * which imports all names defined in the named package directly in the calling module's namespace. Use of this form of import, although supported within the language, is generally discouraged as it pollutes the namespace of the calling module and will cause already defined names to be overwritten in the case of name clashes, though using from import in Python can simplify verbose namespaces, such as nested namespaces.

<span id="mwCN4"></span><span class="kn" id="mwCN8">from</span><span class="w" id="mwCOA"> </span><span class="nn" id="mwCOE">selenium.webdriver</span><span class="w" id="mwCOI"> </span><span class="kn" id="mwCOM">import</span> <span class="n" id="mwCOQ">Firefox</span> <span class="kn" id="mwCOU">from</span><span class="w" id="mwCOY"> </span><span class="nn" id="mwCOc">selenium.webdriver.common.action_chains</span><span class="w" id="mwCOg"> </span><span class="kn" id="mwCOk">import</span> <span class="n" id="mwCOo">ActionChains</span> <span class="kn" id="mwCOs">from</span><span class="w" id="mwCOw"> </span><span class="nn" id="mwCO0">selenium.webdriver.common.by</span><span class="w" id="mwCO4"> </span><span class="kn" id="mwCO8">import</span> <span class="n" id="mwCPA">By</span> <span class="kn" id="mwCPE">from</span><span class="w" id="mwCPI"> </span><span class="nn" id="mwCPM">selenium.webdriver.common.keys</span><span class="w" id="mwCPQ"> </span><span class="kn" id="mwCPU">import</span> <span class="n" id="mwCPY">Keys</span> <span class="kn" id="mwCPc">from</span><span class="w" id="mwCPg"> </span><span class="nn" id="mwCPk">selenium.webdriver.remote.webelement</span><span class="w" id="mwCPo"> </span><span class="kn" id="mwCPs">import</span> <span class="n" id="mwCPw">WebElement</span> <span class="k" id="mwCP0">if</span> <span class="vm" id="mwCP4">__name__</span> <span class="o" id="mwCP8">==</span> <span class="s2" id="mwCQA">"__main__"</span><span class="p" id="mwCQE">:</span> <span class="n" id="mwCQI">driver</span><span class="p" id="mwCQM">:</span> <span class="n" id="mwCQQ">Firefox</span> <span class="o" id="mwCQU">=</span> <span class="n" id="mwCQY">Firefox</span><span class="p" id="mwCQc">()</span> <span class="n" id="mwCQg">element</span><span class="p" id="mwCQk">:</span> <span class="n" id="mwCQo">WebElement</span> <span class="o" id="mwCQs">=</span> <span class="n" id="mwCQw">driver</span><span class="o" id="mwCQ0">.</span><span class="n" id="mwCQ4">find_element</span><span class="p" id="mwCQ8">(</span><span class="n" id="mwCRA">By</span><span class="o" id="mwCRE">.</span><span class="n" id="mwCRI">ID</span><span class="p" id="mwCRM">,</span> <span class="s2" id="mwCRQ">"myInputField"</span><span class="p" id="mwCRU">)</span> <span class="n" id="mwCRY">element</span><span class="o" id="mwCRc">.</span><span class="n" id="mwCRg">send_keys</span><span class="p" id="mwCRk">(</span><span class="sa" id="mwCRo">f</span><span class="s2" id="mwCRs">"Hello World</span><span class="si" id="mwCRw">{</span><span class="n" id="mwCR0">Keys</span><span class="o" id="mwCR4">.</span><span class="n" id="mwCR8">ENTER</span><span class="si" id="mwCSA">}</span><span class="s2" id="mwCSE">"</span><span class="p" id="mwCSI">)</span> <span class="n" id="mwCSM">action</span><span class="p" id="mwCSQ">:</span> <span class="n" id="mwCSU">ActionChains</span> <span class="o" id="mwCSY">=</span> <span class="n" id="mwCSc">ActionChains</span><span class="p" id="mwCSg">(</span><span class="n" id="mwCSk">driver</span><span class="p" id="mwCSo">)</span> <span class="n" id="mwCSs">action</span><span class="o" id="mwCSw">.</span><span class="n" id="mwCS0">key_down</span><span class="p" id="mwCS4">(</span><span class="n" id="mwCS8">Keys</span><span class="o" id="mwCTA">.</span><span class="n" id="mwCTE">CONTROL</span><span class="p" id="mwCTI">)</span><span class="o" id="mwCTM">.</span><span class="n" id="mwCTQ">send_keys</span><span class="p" id="mwCTU">(</span><span class="s1" id="mwCTY">'a'</span><span class="p" id="mwCTc">)</span><span class="o" id="mwCTg">.</span><span class="n" id="mwCTk">key_up</span><span class="p" id="mwCTo">(</span><span class="n" id="mwCTs">Keys</span><span class="o" id="mwCTw">.</span><span class="n" id="mwCT0">CONTROL</span><span class="p" id="mwCT4">)</span><span class="o" id="mwCT8">.</span><span class="n" id="mwCUA">perform</span><span class="p" id="mwCUE">()</span>

Python also supports import x as y as a way of providing an alias or alternative name for use by the calling module:

<span id="mwCU0"></span><span class="kn" id="mwCU4">import</span><span class="w" id="mwCU8"> </span><span class="nn" id="mwCVA">numpy</span><span class="w" id="mwCVE"> </span><span class="k" id="mwCVI">as</span><span class="w" id="mwCVM"> </span><span class="nn" id="mwCVQ">np</span> <span class="kn" id="mwCVU">from</span><span class="w" id="mwCVY"> </span><span class="nn" id="mwCVc">numpy.typing</span><span class="w" id="mwCVg"> </span><span class="kn" id="mwCVk">import</span> <span class="n" id="mwCVo">NDArray</span><span class="p" id="mwCVs">,</span> <span class="n" id="mwCVw">float32</span> <span class="n" id="mwCV0">a</span><span class="p" id="mwCV4">:</span> <span class="n" id="mwCV8">NDArray</span><span class="p" id="mwCWA">[</span><span class="n" id="mwCWE">float32</span><span class="p" id="mwCWI">]</span> <span class="o" id="mwCWM">=</span> <span class="n" id="mwCWQ">np</span><span class="o" id="mwCWU">.</span><span class="kp" id="mwCWY">arange</span><span class="p" id="mwCWc">(</span><span class="mi" id="mwCWg">1000</span><span class="p" id="mwCWk">)</span>

Rust

In Rust, a namespace is called a "module" and declared using mod. Symbols inside the module are by default private, and cannot be accessed externally, unless declared with the pub keyword which exposes them. Modules can have sub-modules inside of them, allowing for nested namespaces.

Similar to the using keyword in C++, Rust has the use keyword to import symbols into the current scope.

<span id="mwCXg"></span><span class="k" id="mwCXk">mod</span><span class="w" id="mwCXo"> </span><span class="nn" id="mwCXs">my_module</span><span class="w" id="mwCXw"> </span><span class="p" id="mwCX0">{</span> <span class="w" id="mwCX4"> </span><span class="k" id="mwCX8">pub</span><span class="w" id="mwCYA"> </span><span class="k" id="mwCYE">trait</span><span class="w" id="mwCYI"> </span><span class="n" id="mwCYM">Greet</span><span class="w" id="mwCYQ"> </span><span class="p" id="mwCYU">{</span> <span class="w" id="mwCYY"> </span><span class="k" id="mwCYc">fn</span><span class="w" id="mwCYg"> </span><span class="nf" id="mwCYk">greet</span><span class="p" id="mwCYo">(</span><span class="o" id="mwCYs">&</span><span class="bp" id="mwCYw">self</span><span class="p" id="mwCY0">);</span> <span class="w" id="mwCY4"> </span><span class="p" id="mwCY8">}</span> <span class="w" id="mwCZA"> </span><span class="k" id="mwCZE">pub</span><span class="w" id="mwCZI"> </span><span class="k" id="mwCZM">struct</span><span class="w" id="mwCZQ"> </span><span class="nc" id="mwCZU">Person</span><span class="w" id="mwCZY"> </span><span class="p" id="mwCZc">{</span> <span class="w" id="mwCZg"> </span><span class="k" id="mwCZk">pub</span><span class="w" id="mwCZo"> </span><span class="n" id="mwCZs">name</span><span class="p" id="mwCZw">:</span><span class="w" id="mwCZ0"> </span><span class="nb" id="mwCZ4">String</span><span class="p" id="mwCZ8">,</span> <span class="w" id="mwCaA"> </span><span class="p" id="mwCaE">}</span> <span class="w" id="mwCaI"> </span><span class="k" id="mwCaM">impl</span><span class="w" id="mwCaQ"> </span><span class="n" id="mwCaU">Greet</span><span class="w" id="mwCaY"> </span><span class="k" id="mwCac">for</span><span class="w" id="mwCag"> </span><span class="n" id="mwCak">Person</span><span class="w" id="mwCao"> </span><span class="p" id="mwCas">{</span> <span class="w" id="mwCaw"> </span><span class="k" id="mwCa0">fn</span><span class="w" id="mwCa4"> </span><span class="nf" id="mwCa8">greet</span><span class="p" id="mwCbA">(</span><span class="o" id="mwCbE">&</span><span class="bp" id="mwCbI">self</span><span class="p" id="mwCbM">)</span><span class="w" id="mwCbQ"> </span><span class="p" id="mwCbU">{</span> <span class="w" id="mwCbY"> </span><span class="fm" id="mwCbc">println!</span><span class="p" id="mwCbg">(</span><span class="s" id="mwCbk">"Hello, {}!"</span><span class="p" id="mwCbo">,</span><span class="w" id="mwCbs"> </span><span class="bp" id="mwCbw">self</span><span class="p" id="mwCb0">.</span><span class="n" id="mwCb4">name</span><span class="p" id="mwCb8">);</span> <span class="w" id="mwCcA"> </span><span class="p" id="mwCcE">}</span> <span class="w" id="mwCcI"> </span><span class="p" id="mwCcM">}</span> <span class="p" id="mwCcQ">}</span> <span class="k" id="mwCcU">fn</span><span class="w" id="mwCcY"> </span><span class="nf" id="mwCcc">main</span><span class="p" id="mwCcg">()</span><span class="w" id="mwCck"> </span><span class="p" id="mwCco">{</span> <span class="w" id="mwCcs"> </span><span class="k" id="mwCcw">use</span><span class="w" id="mwCc0"> </span><span class="n" id="mwCc4">my_module</span><span class="p" id="mwCc8">::{</span><span class="n" id="mwCdA">Person</span><span class="p" id="mwCdE">,</span><span class="w" id="mwCdI"> </span><span class="n" id="mwCdM">Greet</span><span class="p" id="mwCdQ">};</span> <span class="w" id="mwCdU"> </span><span class="kd" id="mwCdY">let</span><span class="w" id="mwCdc"> </span><span class="n" id="mwCdg">person</span><span class="w" id="mwCdk"> </span><span class="o" id="mwCdo">=</span><span class="w" id="mwCds"> </span><span class="n" id="mwCdw">Person</span><span class="w" id="mwCd0"> </span><span class="p" id="mwCd4">{</span><span class="w" id="mwCd8"> </span><span class="n" id="mwCeA">name</span><span class="p" id="mwCeE">:</span><span class="w" id="mwCeI"> </span><span class="nb" id="mwCeM">String</span><span class="p" id="mwCeQ">::</span><span class="n" id="mwCeU">from</span><span class="p" id="mwCeY">(</span><span class="s" id="mwCec">"Alice"</span><span class="p" id="mwCeg">)</span><span class="w" id="mwCek"> </span><span class="p" id="mwCeo">};</span> <span class="w" id="mwCes"> </span><span class="n" id="mwCew">person</span><span class="p" id="mwCe0">.</span><span class="n" id="mwCe4">greet</span><span class="p" id="mwCe8">();</span> <span class="p" id="mwCfA">}</span>

Writing mod util; indicates to the compiler to find either a file named util.rs or util/mod.rs. crate in a use statement refers to the root of the current "crate" (project), while super can be used to refer to the parent module.

<span id="mwCgE"></span><span class="k" id="mwCgI">mod</span><span class="w" id="mwCgM"> </span><span class="nn" id="mwCgQ">util</span><span class="p" id="mwCgU">;</span> <span class="k" id="mwCgY">use</span><span class="w" id="mwCgc"> </span><span class="n" id="mwCgg">std</span><span class="p" id="mwCgk">::</span><span class="n" id="mwCgo">fs</span><span class="p" id="mwCgs">::</span><span class="n" id="mwCgw">File</span><span class="p" id="mwCg0">;</span> <span class="k" id="mwCg4">use</span><span class="w" id="mwCg8"> </span><span class="k" id="mwChA">crate</span><span class="p" id="mwChE">::</span><span class="n" id="mwChI">util</span><span class="p" id="mwChM">::</span><span class="n" id="mwChQ">ConfigLoader</span><span class="p" id="mwChU">;</span> <span class="k" id="mwChY">use</span><span class="w" id="mwChc"> </span><span class="k" id="mwChg">crate</span><span class="p" id="mwChk">::</span><span class="n" id="mwCho">util</span><span class="p" id="mwChs">::</span><span class="n" id="mwChw">logging</span><span class="p" id="mwCh0">::{</span><span class="n" id="mwCh4">Logger</span><span class="p" id="mwCh8">,</span><span class="w" id="mwCiA"> </span><span class="n" id="mwCiE">LoggerFactory</span><span class="p" id="mwCiI">};</span> <span class="k" id="mwCiM">pub</span><span class="w" id="mwCiQ"> </span><span class="k" id="mwCiU">struct</span><span class="w" id="mwCiY"> </span><span class="nc" id="mwCic">App</span><span class="w" id="mwCig"> </span><span class="p" id="mwCik">{</span> <span class="w" id="mwCio"> </span><span class="n" id="mwCis">config_loader</span><span class="p" id="mwCiw">:</span><span class="w" id="mwCi0"> </span><span class="nc" id="mwCi4">ConfigLoader</span><span class="p" id="mwCi8">;</span> <span class="p" id="mwCjA">}</span> <span class="k" id="mwCjE">impl</span><span class="w" id="mwCjI"> </span><span class="n" id="mwCjM">App</span><span class="w" id="mwCjQ"> </span><span class="p" id="mwCjU">{</span> <span class="w" id="mwCjY"> </span><span class="k" id="mwCjc">pub</span><span class="w" id="mwCjg"> </span><span class="k" id="mwCjk">fn</span><span class="w" id="mwCjo"> </span><span class="nf" id="mwCjs">new</span><span class="p" id="mwCjw">()</span><span class="w" id="mwCj0"> </span><span class="p" id="mwCj4">-></span><span class="w" id="mwCj8"> </span><span class="nc" id="mwCkA">Self</span><span class="w" id="mwCkE"> </span><span class="p" id="mwCkI">{</span> <span class="w" id="mwCkM"> </span><span class="n" id="mwCkQ">config_loader</span><span class="w" id="mwCkU"> </span><span class="o" id="mwCkY">=</span><span class="w" id="mwCkc"> </span><span class="n" id="mwCkg">ConfigLoader</span><span class="p" id="mwCkk">::</span><span class="n" id="mwCko">new</span><span class="p" id="mwCks">(</span><span class="n" id="mwCkw">File</span><span class="p" id="mwCk0">::</span><span class="n" id="mwCk4">open</span><span class="p" id="mwCk8">(</span><span class="s" id="mwClA">"config/config_file.txt"</span><span class="p" id="mwClE">));</span> <span class="w" id="mwClI"> </span><span class="n" id="mwClM">config_loader</span><span class="p" id="mwClQ">.</span><span class="n" id="mwClU">load</span><span class="p" id="mwClY">();</span> <span class="w" id="mwClc"> </span><span class="kd" id="mwClg">let</span><span class="w" id="mwClk"> </span><span class="n" id="mwClo">logger</span><span class="p" id="mwCls">:</span><span class="w" id="mwClw"> </span><span class="nc" id="mwCl0">Logger</span><span class="w" id="mwCl4"> </span><span class="o" id="mwCl8">=</span><span class="w" id="mwCmA"> </span><span class="n" id="mwCmE">LoggerFactory</span><span class="p" id="mwCmI">::</span><span class="n" id="mwCmM">get_logger</span><span class="p" id="mwCmQ">(</span><span class="s" id="mwCmU">"Main"</span><span class="p" id="mwCmY">);</span> <span class="w" id="mwCmc"> </span><span class="n" id="mwCmg">logger</span><span class="p" id="mwCmk">.</span><span class="n" id="mwCmo">log</span><span class="p" id="mwCms">(</span><span class="s" id="mwCmw">"Application starting..."</span><span class="p" id="mwCm0">);</span> <span class="w" id="mwCm4"> </span><span class="c1" id="mwCm8">// rest of code</span> <span class="w" id="mwCnA"> </span><span class="p" id="mwCnE">}</span> <span class="p" id="mwCnI">}</span>

The use keyword in Rust is more versatile than its counterpart using in C++. In addition to importing single symbols, symbol aliasing with as and glob imports, use can import multiple symbols on the same line using braces (which may be nested), import individual namespaces, and do all of the above in a single statement. This is an example of using all of the above:

<span id="mwCn4"></span><span class="k" id="mwCn8">use</span><span class="w" id="mwCoA"> </span><span class="n" id="mwCoE">std</span><span class="p" id="mwCoI">::{</span> <span class="w" id="mwCoM"> </span><span class="n" id="mwCoQ">alloc</span><span class="p" id="mwCoU">::</span><span class="n" id="mwCoY">Layout</span><span class="p" id="mwCoc">,</span><span class="w" id="mwCog"> </span><span class="c1" id="mwCok">// imports std::alloc::Layout</span> <span class="w" id="mwCoo"> </span><span class="n" id="mwCos">fmt</span><span class="p" id="mwCow">::</span><span class="o" id="mwCo0">*</span><span class="p" id="mwCo4">,</span><span class="w" id="mwCo8"> </span><span class="c1" id="mwCpA">// imports all symbols in std::fmt</span> <span class="w" id="mwCpE"> </span><span class="n" id="mwCpI">fs</span><span class="p" id="mwCpM">::{</span><span class="n" id="mwCpQ">File</span><span class="p" id="mwCpU">,</span><span class="w" id="mwCpY"> </span><span class="n" id="mwCpc">Metadata</span><span class="p" id="mwCpg">},</span><span class="w" id="mwCpk"> </span><span class="c1" id="mwCpo">// imports std::fs::File and std::fs::Metadata</span> <span class="w" id="mwCps"> </span><span class="n" id="mwCpw">io</span><span class="p" id="mwCp0">::{</span><span class="n" id="mwCp4">prelude</span><span class="p" id="mwCp8">::</span><span class="o" id="mwCqA">*</span><span class="p" id="mwCqE">,</span><span class="w" id="mwCqI"> </span><span class="n" id="mwCqM">BufReader</span><span class="p" id="mwCqQ">,</span><span class="w" id="mwCqU"> </span><span class="n" id="mwCqY">BufWriter</span><span class="p" id="mwCqc">}</span><span class="w" id="mwCqg"> </span><span class="c1" id="mwCqk">// imports all symbols in std::io::prelude::*, std::io::BufReader, and std::io::BufWriter</span> <span class="w" id="mwCqo"> </span><span class="n" id="mwCqs">process</span><span class="p" id="mwCqw">,</span><span class="w" id="mwCq0"> </span><span class="c1" id="mwCq4">// imports the std::process namespace (for example std::process::Command can be referred to as process::Command)</span> <span class="w" id="mwCq8"> </span><span class="n" id="mwCrA">time</span><span class="p" id="mwCrE">::{</span><span class="bp" id="mwCrI">self</span><span class="p" id="mwCrM">,</span><span class="w" id="mwCrQ"> </span><span class="n" id="mwCrU">Duration</span><span class="p" id="mwCrY">}</span><span class="w" id="mwCrc"> </span><span class="c1" id="mwCrg">// imports the std::time namespace and std::time::Duration</span> <span class="p" id="mwCrk">};</span> <span class="k" id="mwCro">use</span><span class="w" id="mwCrs"> </span><span class="n" id="mwCrw">std</span><span class="p" id="mwCr0">::</span><span class="n" id="mwCr4">fmt</span><span class="p" id="mwCr8">::</span><span class="nb" id="mwCsA">Result</span><span class="w" id="mwCsE"> </span><span class="k" id="mwCsI">as</span><span class="w" id="mwCsM"> </span><span class="n" id="mwCsQ">FmtResult</span><span class="p" id="mwCsU">;</span><span class="w" id="mwCsY"> </span><span class="c1" id="mwCsc">// renames std::fmt::Result to FmtResult</span>

XML namespace

In XML, the XML namespace specification enables the names of elements and attributes in an XML document to be unique, similar to the role of namespaces in programming languages. Using XML namespaces, XML documents may contain element or attribute names from more than one XML vocabulary.

SAP Namespace

In SAP systems (especially ABAP environments), namespaces are used to prevent naming collisions between standard SAP-delivered objects and customer or partner developments.

A namespace identifier is delimited with “/” (for example `/MYNS/`) and is reserved via SAP’s namespace registration process. Once reserved, objects created under that namespace are uniquely identifiable and protected from unintended overwrite by SAP upgrades or imports.

In modern SAP landscapes (such as ABAP in the cloud and HDI containers), namespaces are also used to semantically group development artifacts or bundles.

Emulating namespaces

In programming languages lacking language support for namespaces, namespaces can be emulated to some extent by using an identifier naming convention. For example, C libraries such as libpng often use a fixed prefix for all functions and variables that are part of their exposed interface. Libpng exposes identifiers such as:

png_create_write_struct png_get_signature png_read_row png_set_invalid

This naming convention provides reasonable assurance that the identifiers are unique and can therefore be used in larger programs without naming collisions. Likewise, many packages originally written in Fortran (e.g., BLAS, LAPACK) reserve the first few letters of a function's name to indicate the group to which the function belongs.

This technique has several drawbacks:

• It doesn't scale well to nested namespaces; identifiers become excessively long since all uses of the identifiers must be fully namespace-qualified;
• Individuals or organizations may use inconsistent naming conventions, potentially introducing unwanted obfuscation;
• Compound or "query-based" operations on groups of identifiers, based on the namespaces in which they are declared, are rendered unwieldy or unfeasible;
• In languages with restricted identifier length, the use of prefixes limits the number of characters that can be used to identify what the function does; this is a particular problem for packages originally written in FORTRAN 77, which offered only 6 characters per identifier; for example, the name of the BLAS function DGEMM indicates that it operates on double-precision floating-point numbers (D) and general matrices (GE), with only the last two characters (MM) showing what it actually does: matrix–matrix multiplication.

It also has a few advantages:

• No special software tools are required to locate names in source-code files; a simple program like grep suffices;
• There are no namespace-related name conflicts;
• There is no need for name mangling, and thus no potential incompatibility problems.