Nasal Namespaces in-depth: Difference between revisions

== Hands-On Example ==

Let's consider a common operation to perform. As I'm sure you all know, to put the gear down from a joystick button (which is in the namespace __js0 for example), you call a script like this:

controls.gearDown(1);

</syntaxhighlight>

Namespaces also resemble hashes in another way – they in fact are hashes! Nasal thinks of namespaces as just another hash, and this can challenge a common notion of programmers, that of "lvalues". Typically, programmers can only declare named variables that are legal lvalues – that is, they have to fit a certain pattern. The pattern is usually something like this: a name can start with an underscore or alpha character and all remaining characters must be an underscore or an alphanumeric character. The lvalue ends at the first character that doesn't fit that pattern, e.g. a punctuation mark or bit of white space. But in Nasal hashes, one can use arbitrary scalars (strings or numbers) as hash indexes:

a_hash["(illegal lvalue)"] = 78;

</syntaxhighlight>

This means that namespaces can contain ‘variables’ that aren't valid lvalues and thus can't be used in typical code. Also notice that the dialog's namespaces are not lvalues, as they have punctuation in them, and thus can't be used like the controls namespace can. Instead, one must use various methods to access non-lvalues, like indexing the globals namespace (though this is ''not'' recommended as they are supposed to be "private"):

globals["__dlg:foo"].setName("foo");

</syntaxhighlight>

== Dealing with Different Objects that have the Same Name ==

Back to the graph: each portion of the graph has its own variables, some of which might be functions with their own namespaces, and some are hashes that are used as objects or namespaces. We learned that the Nasal code executor looks first at the current namespace for a symbol, then the next higher namespace, until it reaches the top. But what if we define a variable in this scope and we want to access another variable that has the same name but lives in a different namespace? This is what happens in debug.nas; it defines a string function which obscures the string namespace (in computer science this is called [en.wikipedia.org/Variable_Shadowing shadowing]). To use the string namespace, there are two options: use caller() to manually "hop" up the namespace tree or prefix "globals<nowiki>[dot]</nowiki>" to the symbol like this:

globals.string.isascii(n);

</syntaxhighlight>

Here is the reason why prefixing "globals" even works (be warned that it doesn't hold for other Nasal implementations!):

-+- [flightgear]/src/Scripting/NasalSys.cxx, line 634 -+-

     // Start with globals.  Add it to itself as a recursive

Consider what we learned: functions are anonymous and they create new namespaces. Now consider this: anonymous namespaces. Nasal can create these by making anonymous functions and immediately evaluating it. Let's look at an example from io.nas to create a layer of security over removelistener():

     # wrap removelistener

     globals.removelistener = (func {

* bind()

These all deal with namespaces is some way, shape, or form: closure() gives the namespace (closure) of the function at the specified level – more on this later; bind() can modify those closure (somewhat indirectly); caller() gives info about the caller: locals namespace, function, name of source file, currently executing line; and call() gives enormous control over how a function is executed, from the 'me' variable and the arguments to the namespace it will be executed in. The ‘official’ prototype given for the latter is this:

call(fn, args=[], me=nil, namespace=nil, error=nil)

</syntaxhighlight>

=== Example: Class Constructor ===

Let's say you are making your own class in Nasal and you have a gazillion members you new() method needs to populate. Each member is passed in as an argument which gets tiring for you (also limits you to 16 members, as functions can't have more arguments than that). This is what a first attempt might look like:

var class = {

     new: func(a, b, c, d, e) {

</syntaxhighlight>

And it goes on and on. What if you could just do it automatically? Your first attempt might go like this:

var class = {

     new: func(a, b, c, d, e) {

</syntaxhighlight>

But this is still a little inefficient as you have to manually add each symbol. There are two ways around this. Firstly, you could do a foreach on the symbols in the namespace and ignore the symbols if it is "m" – that is, our hash we are populating. Or you could wrap that in a function which generates the hash itself and doesn't need to skip it. Here they are in order:

var class = {

     new: func(a, b, c, d, e) {

};

</syntaxhighlight>

var _gen_new = func() {

     var symbols = caller(1)[0];