Re: Suggestion: module opcall

[bearophile]

Bill Baxter:

>I think this problem you refer to only applies to modules without package 
>names.  I.e. "module Foo" containing "class Foo".  Things seem to work ok if 
>you have "module x.Foo" with "class Foo" inside.<

Right. But why settle with a half-backed module system when there are more 
logic ways to design it? :-)


> So you are saying you want this to be an error?
> 
> import std.string;
> void foo() {
>     std.string.format("hi");  // error no such symbol "std.string"
>     format("hi");   // ok
> }


The following examples show what I mean:

import std.string;
void foo() {
    std.string.format("hi"); // OK, "std.string" name exists in the current 
scope.
    format("hi"); // Error, "format" name is absent.
}


import std.string: format;
void foo() {
    std.string.format("hi"); // Error, "std" name is absent.
    format("hi"); // OK.
}


import std.string: *;
void foo() {
    std.string.format("hi"); // Error, "std" name is absent.
    format("hi"); // OK, all names inside "std.string" are now present in the 
current scope.
}


import std.string;
import std.string: format;
void foo() {
    std.string.format("hi"); // OK.
    format("hi"); // OK.
}

This doesn't solve all problems, but it's a good step toward improving the 
situation.



>auto x = new Foo;  // Foo.Foo should not be needed if class Foo is the only 
>thing inside Foo.<

That's a special casing, it may look handy, but it may also lead to troubles 
later. So I think it's better to keep things tidy, and avoid that. D allows 
enough things (renamed imports, alias, and selective imports) to solve such 
problems already.


> template AReallyLongTemplateNameIDontWannaTypeTwice(T) {
>      void this(T x) { }
> }

You can write that in D1 as:

void aReallyLongTemplateNameIDontWannaTypeTwice(T)(T x) {
}


>I love how I don't have to change all the constructor names in D whenever I 
>change a class name.<

I agree, but for example when you define a opCmp of a struct you have to do:

struct Foo {
    int x;
    int opCmp(Foo other) { ...

As you can see the name Foo is repeated two times, and I don't like that much 
(I don't use an IDE able to refractor names).
In D1 I sometimes solve that small problem like this:

struct Foo {
    int x;
    int opCmp(typeof(*this) other) { ...

Or like this:

struct Foo {
    int x;
    alias typeof(*this) TyThis;
    int opCmp(TyThis other) { ...

Bye,
bearophile