www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Is this correct?

reply Jonathan Marler <johnnymarler gmail.com> writes:
The named arguments DIP got to question what this example would 
do:

--- foolib.d
import std.stdio;
void foo(string s) { writefln("foo string"); }


--- main.d
import std.stdio;
import foolib;
void foo(const(char)[] s) { writefln("foo const"); }
void main()
{
    foo("hello");
}


This prints "foo const".  And if you move the function overload 
from foolib.d to main.d, it will print "foo string".  Is this the 
expected behavior?
Feb 06
next sibling parent Adam D. Ruppe <destructionator gmail.com> writes:
On Thursday, 6 February 2020 at 23:05:19 UTC, Jonathan Marler 
wrote:
 Is this the expected behavior?
Yes. (at least for those of us intimately familiar with the spec, lol, it is a faq among others) This is the anti-hijacking rule described here: https://dlang.org/articles/hijack.html Local functions are NOT overloaded against functions from a different namespace. If you want that, you must explicitly opt in by doing `alias foo = other.module.foo`
Feb 06
prev sibling next sibling parent Steven Schveighoffer <schveiguy gmail.com> writes:
On 2/6/20 6:05 PM, Jonathan Marler wrote:
 The named arguments DIP got to question what this example would do:
 
 --- foolib.d
 import std.stdio;
 void foo(string s) { writefln("foo string"); }
 
 
 --- main.d
 import std.stdio;
 import foolib;
 void foo(const(char)[] s) { writefln("foo const"); }
 void main()
 {
     foo("hello");
 }
 
 
 This prints "foo const".  And if you move the function overload from 
 foolib.d to main.d, it will print "foo string".  Is this the expected 
 behavior?
 
Yes. Overloads sets are delineated by scope, from inner to outer. All imported modules count as a further outer scope. See information here: https://dlang.org/spec/function.html#overload-sets In order to bring imported symbols into your overload set, you need to alias them. Also you could selectively import the symbol to get it into the module's namespace. --- main.d import std.stdio; import foolib; alias foo = foolib.foo; // this or import foolib: foo; void foo(const(char)[] s) { writefln("foo const"); } void main() { foo("hello"); } --- prints foo string As a demonstration to realize it stops at your module's scope, change the local foo to accept an int (and don't alias in the external foo), and you will get an error even though foolib.foo could accept the parameter. -Steve
Feb 06
prev sibling next sibling parent Timon Gehr <timon.gehr gmx.ch> writes:
On 07.02.20 00:05, Jonathan Marler wrote:
 The named arguments DIP got to question what this example would do:
 
 --- foolib.d
 import std.stdio;
 void foo(string s) { writefln("foo string"); }
 
 
 --- main.d
 import std.stdio;
 import foolib;
 void foo(const(char)[] s) { writefln("foo const"); }
 void main()
 {
     foo("hello");
 }
 
 
 This prints "foo const".  And if you move the function overload from 
 foolib.d to main.d, it will print "foo string".  Is this the expected 
 behavior?
 
Yes. The justification for this is that otherwise foolib could silently hijack your main.d by introducing a new function "foo". If you want to overload against the library function, you can use an alias: import std.stdio; import foolib; alias foo=foolib.foo; void foo(const(char)[] s) { writefln("foo const"); } void main(){ foo("hello"); // foo string }
Feb 06
prev sibling next sibling parent Petar Kirov [ZombineDev] <petar.p.kirov gmail.com> writes:
On Thursday, 6 February 2020 at 23:05:19 UTC, Jonathan Marler 
wrote:
 The named arguments DIP got to question what this example would 
 do:

 --- foolib.d
 import std.stdio;
 void foo(string s) { writefln("foo string"); }


 --- main.d
 import std.stdio;
 import foolib;
 void foo(const(char)[] s) { writefln("foo const"); }
 void main()
 {
    foo("hello");
 }


 This prints "foo const".  And if you move the function overload 
 from foolib.d to main.d, it will print "foo string".  Is this 
 the expected behavior?
It's surprising, but it has to do with how overload sets are created. You can get the "foo string" by using a selective import: --- foolib.d import std.stdio; void foo(string s) { writefln("foo string"); } --- main.d import std.stdio; import foolib : foo; void foo(const(char)[] s) { writefln("foo const"); } void main() { foo("hello"); } Which is essentially equivalent to a private alias: --- foolib.d import std.stdio; void foo(string s) { writefln("foo string"); } --- main.d import std.stdio; import foolib; private alias foo = foolib.foo; void foo(const(char)[] s) { writefln("foo const"); } void main() { foo("hello"); } The idea is that local symbols must take precedence (anti-hijacking principle - adding imports should not change the meaning of your code). Overloading works when all symbols are declared in the same scope. For example, if both overloads of foo were in foolib, then they would naturally overload (with both normal or selective imports). Adding an alias is essentially creating a symbol in the local scope - a "symlink" to another symbol. So overload a symbol A in scope S1 with symbol B in S2, you need to add 'alias A = S2.B' in scope S1. Cheers, Petar
Feb 06
prev sibling parent Walter Bright <newshound2 digitalmars.com> writes:
On 2/6/2020 3:05 PM, Jonathan Marler wrote:
 The named arguments DIP got to question what this example would do:
To everyone who replied: All great answers!
Feb 06