On Tuesday, 31 May 2022 at 19:59:21 UTC, Steven Schveighoffer wrote:

What's the purpose? It looks like just another atavism, reproducing itself without any purpose.

On 5/31/22 4:11 PM, Ola Fosheim Grøstad wrote:

Because they aren't lambdas. To use your example:

void main()
{
    int i;
    void foo(); // declares foo with no definition

    auto bar = (){
        writeln("Hello world");
        if(++i < 10) foo();
    };

    void foo() {bar(); }; // redeclares foo, not allowed

    foo();
}

would be the same with lambdas as:

void main()
{
    int i;
    void delegate() foo; // declares foo and assigns it to null

    auto bar = (){
        writeln("Hello world");
        if(++i < 10) foo();
    };

    //foo = (){ bar(); }; // this is NOT a declaration, it's an assignment
    void delegate() foo = () {bar(); }; // redeclares foo, not allowed

    foo();
}

You can't "assign" functions like you can lambdas. And D does not allow redeclaring a symbol of any type in a specific scope.

-Steve

On 5/31/22 4:13 PM, Max Samukha wrote:

To make code that is ported from C compile the same as it does in C.

-Steve

On Tuesday, 31 May 2022 at 20:24:17 UTC, Steven Schveighoffer wrote:

    void foo() {bar(); }; // redeclares foo, not allowed

This ought to define what has already been declared. That is the purpose of a prototype. Calling this a "redeclaration" is arbitrary.

    void delegate() foo; // declares foo and assigns it to null

This declares and defines foo.

Why do you call it "redeclaring" the signature is the same!? That's just an after-the-fact explanation. Calling this redeclaring doesn't follow from how prototypes in C works. If the signature is the same then you can do it as many times as you want.

On 5/31/22 4:33 PM, Ola Fosheim Grøstad wrote:

    void foo() {bar(); }; // redeclares foo, not allowed

I don't know why it does that, I assume Walter has a good reason for that. But they do work at module level (which is kinda weird, since you don't need them there). I had thought they weren't allowed.

I can't do:

int x;
int x = 5;

So I assume it's similar to declaring functions, but I don't know the reason it allows this for function prototypes at the module level.

-Steve

On Tuesday, 31 May 2022 at 20:47:36 UTC, Steven Schveighoffer wrote:

Maybe he didn't think about mutual recursion.

Anyway, this is legal in C++:

extern int x;
extern int x;
void f();
void f();
void f(){ x=0;}
int x = 1;

On Tuesday, 31 May 2022 at 19:59:21 UTC, Steven Schveighoffer wrote:

void foo() { bar(); }
void bar() { writeln("hello"); }
foo();

void foo() { bar(); }
foo();
void bar() { writeln("hello"); }

void foo() { writeln("outer foo"); }


void main()
{
   void bar() { foo(); }
   void foo() { writeln("inner foo"); }
   bar();
}

Because D has chosen to define its version of lexical scoping in this way in this case, but not other cases. What you say would not be controversial if we were talking about

     int bar = foo + 1;
     int foo = 0;

That doesn't work in D, Scheme or Haskell, nor should it, because the value of a variable not yet defined is required in the course of sequential evaluation of the statements above.

But in the situation I encountered, the sequential evaluation is of function definitions. The forward reference is within one of those definitions and the actual reference does not occur until the function is invoked, at which point both functions have been defined and therefore I would expect foo and bar to be available to each other. What D is doing here makes no sense to me and is particularly bizarre because it does the opposite at top level and inside structs.

Well, I would argue that that kind of thinking leads to a language that is a collection of special cases, rather than a language built on a core set of principles consistently applied.

Ok. I've had my say. I think this is a mistake, but I don't expect it to change because of my objection, so no point in pursuing.

My concern is not "solving this". My concern is whether the language is clean and consistent so I can have mental model of it I can rely upon, rather than constantly searching through documentation to learn how a particular special case is handled. I also care a lot about writing readable code, and about being able to limit the visibility of variables to just the scope that needs them and no more. The workarounds you cite frankly feel like hacks to me, ugly ways of working around problems in the language design.

/Don

On 5/31/22 8:17 PM, Timon Gehr wrote:

I mean the lookup mechanisms are the same.

But yeah, there are no local functions in C. I just figured that this is so the compiler doesn't have to have weird special cases for lookups.

However, thinking about it more, we do allow function prototypes as local functions. But I can't figure out a way to actually define them, aside from using pragma(mangle).

I think there's an opportunity here where we can allow function prototypes, allow definitions later, and not break existing code.

-Steve