Language Design: skipping occurrences of an identifier instead of accessing enclosing scope

As I understand it, you're suggesting a construct: @ prefixed to an identifier, e.g. @foo, which goes to the next (2nd) visible foo starting from the current scope going to outer scopes.

Thus, writing @foo requires the existence of a 2 foos in the scope (one hiding the other).

I don't care for the design, because it means the code written using that construct, e.g. @foo, captures with it acknowledgement of the presence of another foo (that it isn't interested in) making the code more brittle, because — to one way of looking at it — it is a reference of both foos.

Code written using @@foo implicitly captures the existence of two other foos that it is not interested in.

This suggests to me that simple code will be prone to more copy & paste errors.

(Further, a foo and bar at the same scope may require @ for one but not the other — I'd rather qualify both or none, as in the examples you provide, re: this. and global::.)

Think how easy it is to make an mistake. For example if someone writes

@@foo = @foo

instead of

@foo = @@foo

Now how long do you think it would take your novice programmers to spot this error.

What i think would make more sense is to make it easy to find which foo you one.

For example

• @global.foo (ok i understand this one)
• bar.foo (this is the foo defined in the bar object)
• bla.foo (this is the foo defined in the bla function)

But that's assuming you would really need to access the outerlying scopes at all. in my opionion a DSL should be about minimizing complexity. So introduce tooling that avoids the need of something like this at all. A DSL should be about writing business rules in the way they understand it. If you have nesting your scopes 5 deep then you are on the wrong path.

Update: An other way of dealing with this issue is to never allow 'regular' global variables. If a global variable is always defined and called (explicitly) as "global.foo" then you also avoid the clash in naming between 2 foo variables. A user would have to define a variable like this

let global.foo = 5

if he wanted a global variable

Such language constructs are not really necessary: If a user wants to access a symbol in a surrounding scope, they could first create an alias for the outer symbol in the outer scope with a different name:

let foo = "outer"
let outer_foo = foo
{
  let foo = "inner"
  // can use foo and outer_foo
}

Most mainstream programming languages therefore have no mechanism to access outer scopes from a nested scope. Related but completely different:

• accessing instance members like this.foo in Java, C#; this->foo in C++; @foo in Ruby.
• looking up a symbol in a (global) namespace (ike name.space.Symbol in Java, C#, Python; name::space::Symbol in C++, Perl.

A notable exception is Python, where the nonlocal and global keywords can be used to bring a variable into scope. But this is necessary because you cannot declare a Python variable: whenever you assign to a variable, it is created in the innermost scope.

In less common languages, operators to access outer scopes do exist. One example is the Handlebars template language, which uses a filepath-like syntax: {{foo}} accesses the variable in the current scope, {{../foo}} looks at the parent scope, {{../../foo}} at the second-parent scope and so on. In Perl6, the OUTER pseudo-namespace lets you look outwards, as in OUTER::Symbol, OUTER::OUTER::Symbol and so on. It also has lots of other pseudo-namespaces, such as OUTERS:: which means “any outer scope, you don't have to count”.

Is this a good idea? Possibly. Although not strictly necessary or a good idea, accessing outer scopes is probably convenient. Especially if you don't want to explain the concept of “lexical scope” to your users. I think, but have no evidence, that Perl6's pseudo-namespace solution is the most elegant approach here for block scopes. Using an explicit name like outer is probably better than using a scope-walking symbol like @ unless you are already using Perl- or Ruby-like Sigils in your language.

However, these explicit outer-scopes do have an universal problem: you generally have to carefully count the required levels, which makes the code harder to refactor and copy-paste: if put the code into a different context, the scope level counts will probably be off.

For object-oriented code, a classic keyword like this, self, my or currentObject might be more sensible, in which symbol access happens just like with any other object.

Some problems

1. As a matter of principle-- control of scope is a very important concern for programmers. Making it easier to play fast and loose with scope is likely to introduce more complexity, not less, because poor control of scope makes dependency tracing more difficult.

2. Indicating scope via a relative number (the number of @ symbols) is prone to error since scope leveling may change if, say, you move the code, or if you remove a layer. I am not sure how your language will be structured, but do if and while blocks have their own scope? Can you have nested classes? Any sort of nesting would result in utter confusion, especially if you were to move code from inside a block to the outside of that block. You'd have to go through and change every @@ to a @.

3. You can end up with two symbols representing the same variable, e.g. @foo and @@foo might refer to the same memory location if they are used in different layers of the code. That to me is utterly confusing.

4. If your programmers don't understand what global scope is, there isn't a language construct in the universe that will help them out of that.

Perl can do something similar to what you suggest but you have to set it up to do so. This technique will work with both lexical and dynamic variables.

Using lexical variables:

my $foo = 'begin';
my $foo_ref = \$foo;
print "foo=$foo foo_ref=$$foo_ref # both the same at the beginning\n";

{
    my $foo = 'inner';
    print "foo=$foo foo_ref=$$foo_ref # foo changes but foo_ref remains the same\n";

    # magic
    $$foo_ref = 'magic';
    print "foo=$foo foo_ref=$$foo_ref # foo_ref changes but foo is still inner\n";
}
print "foo=$foo foo_ref=$$foo_ref # outer foo changed when foo_ref did\n";

Using dynamic variables:

our $foo = 'begin';
our $foo_ref = \$foo;
print "foo=$foo foo_ref=$$foo_ref # both the same at the beginning\n";

{
    local $foo = 'inner';
    print "foo=$foo foo_ref=$$foo_ref # foo changes but foo_ref remains the same\n";

    # magic
    $$foo_ref = 'magic';
    print "foo=$foo foo_ref=$$foo_ref # foo_ref changes but foo is still inner\n";
}
print "foo=$foo foo_ref=$$foo_ref # outer foo changed when foo_ref did\n";