www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - return in void functions

reply bearophile <bearophileHUGS lycos.com> writes:
D has safeties to avoid this kind of code, because it's essentially considered
a bug:

int foo() {}
void main() {
    foo();
}


But this compiles with no errors:

void foo() {
    return 1;
}
void main() {
    foo();
}


Notice that this Java code:

class Test {
	static void foo() {
		return 1;
	}

    public static void main(String[] args) {
		Test.foo();
    }
}

Raises a compilation error:

Test.java:3: cannot return a value from method whose result type is void
                return 1;
                       ^
1 error

I think this avoids some mistakes.

Bye,
bearophile
Mar 04 2009
next sibling parent reply BCS <ao pathlink.com> writes:
Reply to bearophile,


 But this compiles with no errors:
 
 void foo() {
 return 1;
 }
 void main() {
 foo();
 }

IIRC D allows "return exp;" in a void function because it avoids special cases in template code. ReturnTypeOf!(AFn, T) fn(T)(T t) { return AFn(t,t); // AFn might return void }
Mar 04 2009
next sibling parent reply Daniel Keep <daniel.keep.lists gmail.com> writes:
BCS wrote:
 Reply to bearophile,
 
 
 But this compiles with no errors:

 void foo() {
 return 1;
 }
 void main() {
 foo();
 }

IIRC D allows "return exp;" in a void function because it avoids special cases in template code. ReturnTypeOf!(AFn, T) fn(T)(T t) { return AFn(t,t); // AFn might return void }

Sadly, this doesn't help if you need to cache the result before exiting. I personally wish we could create void *variables*. -- Daniel
Mar 04 2009
parent reply grauzone <none example.net> writes:
Daniel Keep wrote:
 
 BCS wrote:
 Reply to bearophile,


 But this compiles with no errors:

 void foo() {
 return 1;
 }
 void main() {
 foo();
 }

cases in template code. ReturnTypeOf!(AFn, T) fn(T)(T t) { return AFn(t,t); // AFn might return void }

Sadly, this doesn't help if you need to cache the result before exiting. I personally wish we could create void *variables*.

I wonder if we'd lose anything if the void datatype was completely removed and replaced by a "struct void {}" declaration in object.d?
   -- Daniel

Mar 04 2009
next sibling parent Daniel Keep <daniel.keep.lists gmail.com> writes:
grauzone wrote:
 Daniel Keep wrote:
 BCS wrote:
 Reply to bearophile,


 But this compiles with no errors:

 void foo() {
 return 1;
 }
 void main() {
 foo();
 }

cases in template code. ReturnTypeOf!(AFn, T) fn(T)(T t) { return AFn(t,t); // AFn might return void }

Sadly, this doesn't help if you need to cache the result before exiting. I personally wish we could create void *variables*.

I wonder if we'd lose anything if the void datatype was completely removed and replaced by a "struct void {}" declaration in object.d?
   -- Daniel


T x = void; Interesting idea, though. -- Daniel
Mar 05 2009
prev sibling parent Max Samukha <samukha voliacable.com.removethis> writes:
On Thu, 05 Mar 2009 08:40:34 +0100, grauzone <none example.net> wrote:

Daniel Keep wrote:
 
 BCS wrote:
 Reply to bearophile,


 But this compiles with no errors:

 void foo() {
 return 1;
 }
 void main() {
 foo();
 }

cases in template code. ReturnTypeOf!(AFn, T) fn(T)(T t) { return AFn(t,t); // AFn might return void }

Sadly, this doesn't help if you need to cache the result before exiting. I personally wish we could create void *variables*.

I wonder if we'd lose anything if the void datatype was completely removed and replaced by a "struct void {}" declaration in object.d?

That would be awesome. Would foo() and foo(void) be distinct overloads, one taking no arguments and the other taking a void argument? Should voids be allowed to be declared directly or only passed to template parameters?
   -- Daniel


Mar 05 2009
prev sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
BCS wrote:
 IIRC D allows "return exp;" in a void function because it avoids special 
 cases in template code.
 
 ReturnTypeOf!(AFn, T) fn(T)(T t)
 {
    return AFn(t,t); // AFn might return void
 }

Yes, that's exactly why.
Mar 04 2009
next sibling parent reply "Nick Sabalausky" <a a.a> writes:
"Walter Bright" <newshound1 digitalmars.com> wrote in message 
news:gomvoo$1m3b$3 digitalmars.com...
 BCS wrote:
 IIRC D allows "return exp;" in a void function because it avoids special 
 cases in template code.

 ReturnTypeOf!(AFn, T) fn(T)(T t)
 {
    return AFn(t,t); // AFn might return void
 }

Yes, that's exactly why.

There has to be a better way to handle that. Making "void foo(){return 1;}" valid code with no warning is just plain sloppy. (In fact, I've been bitten by that before.)
Mar 04 2009
next sibling parent BCS <none anon.com> writes:
Hello Nick,


 There has to be a better way to handle that.  Making "void
 foo(){return 1;}" valid code with no warning is just plain sloppy. (In
 fact, I've been bitten by that before.)
 

I wouldn't mind seeing it limited to "return FnReturningVoid();"
Mar 04 2009
prev sibling parent Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Nick Sabalausky wrote:
 "Walter Bright" <newshound1 digitalmars.com> wrote in message 
 news:gomvoo$1m3b$3 digitalmars.com...
 BCS wrote:
 IIRC D allows "return exp;" in a void function because it avoids special 
 cases in template code.

 ReturnTypeOf!(AFn, T) fn(T)(T t)
 {
    return AFn(t,t); // AFn might return void
 }


There has to be a better way to handle that. Making "void foo(){return 1;}" valid code with no warning is just plain sloppy. (In fact, I've been bitten by that before.)

I agree. It's fine to forward a void to a void, but not anything else to a void. Andrei
Mar 04 2009
prev sibling next sibling parent Yigal Chripun <yigal100 gmail.com> writes:
Walter Bright wrote:
 BCS wrote:
 IIRC D allows "return exp;" in a void function because it avoids
 special cases in template code.

 ReturnTypeOf!(AFn, T) fn(T)(T t)
 {
 return AFn(t,t); // AFn might return void
 }

Yes, that's exactly why.

D is becoming more functional and the functional way is to use a unit type. why not turn D's void from C style keyword to a unit type?
Mar 04 2009
prev sibling parent reply Stewart Gordon <smjg_1998 yahoo.com> writes:
Walter Bright wrote:
 BCS wrote:
 IIRC D allows "return exp;" in a void function because it avoids 
 special cases in template code.

 ReturnTypeOf!(AFn, T) fn(T)(T t)
 {
    return AFn(t,t); // AFn might return void
 }

Yes, that's exactly why.

Why it allows you to return an int from a void-returning function??? Stewart.
Mar 07 2009
parent Georg Wrede <georg.wrede iki.fi> writes:
Stewart Gordon wrote:
 Walter Bright wrote:
 BCS wrote:
 IIRC D allows "return exp;" in a void function because it avoids 
 special cases in template code.

 ReturnTypeOf!(AFn, T) fn(T)(T t)
 {
    return AFn(t,t); // AFn might return void
 }

Yes, that's exactly why.

Why it allows you to return an int from a void-returning function???

C does that, too. void foo() { return 23; } int main() { foo(); } Running the program gives random values as the exit status. Changing void to int returns always 23. (Actually I would have thought that it'd give 23 in both cases. But I guess the assignment of 23 into the return register doesn't get compiled when void is used.) ---- Anyway, I don't think this is such a big deal. Fixing this may be a lot of work, and I haven't heard anyone complain about it, in C or D, before. It's a blemish, but one we can live with.
Mar 08 2009
prev sibling next sibling parent Georg Wrede <georg.wrede iki.fi> writes:
bearophile wrote:
 D has safeties to avoid this kind of code, because it's essentially considered
a bug:
 
 int foo() {}
 void main() {
     foo();
 }
 
 
 But this compiles with no errors:
 
 void foo() {
     return 1;
 }
 void main() {
     foo();
 }

No error in C either, only a warning. This being an easy thing to fix, one would think it'd been fixed ages ago already. Therefore, one only assumes there to be a motivation for having it like this.
Mar 06 2009
prev sibling parent Christopher Wright <dhasenan gmail.com> writes:
bearophile wrote:
 D has safeties to avoid this kind of code, because it's essentially considered
a bug:
 
 But this compiles with no errors:
 
 void foo() {
     return 1;
 }
 void main() {
     foo();
 }

This is an error you'll catch very quickly. If you never use the function, you won't have an error, which is a problem if you're releasing a library that you did not test.
Mar 06 2009