c:\dmd\bin\..\src\phobos\std\string.d(502): function toupper conflicts with ctype.toupper at c:\dmd\bin\..\src\phobos\std\ctype.d(36)

Anyone else getting this?

-- 
dave

Dave Sieber wrote:
> c:\dmd\bin\..\src\phobos\std\string.d(502): function toupper conflicts with ctype.toupper at c:\dmd\bin\..\src\phobos\std\ctype.d(36)

I assume you're talking about code like this...

import std.ctype;
import std.string;

void main()
{
	char[] s = "some string";
	s = toupper(s);
	printf("%.*s\n", s);
}


> 
> Anyone else getting this?
Yes, but there's a couple of ways to get the code to compile.

If you're just using toupper once, the best thing to do is probably refer to the name of the module you want to disambiguate:

s = std.string.toupper(s);
or
s = std.ctype.toupper(s);

Also (especially if you use this function a lot of times), you could use an alias near the  top of your program like this:

import std.ctype;
import std.string;
alias std.string.toupper toupper; /* selects the std.string function */

void main()
{
	char[] s = "some string";
	s = std.string.toupper(s);
	printf("%.*s\n", s);
}


-- 
Justin
http://jcc_7.tripod.com/d/

J C Calvarese <jcc7@cox.net> wrote:

> I assume you're talking about code like this...
> 
> import std.ctype;
> import std.string;
> 
> void main()
> {
>      char[] s = "some string";
>      s = toupper(s);
>      printf("%.*s\n", s);
> }

Yes, that's basically it, but I was needing toupper() on a character.

> If you're just using toupper once, the best thing to do is probably refer to the name of the module you want to disambiguate:
> 
> s = std.string.toupper(s);
> or
> s = std.ctype.toupper(s);

Cool, this works. But I'm not sure I understand why -- aren't the two functions unambiguous?

char[] toupper(char[] s)
dchar toupper(dchar c)

When I import both std.string and std.ctype, even this doesn't work:

dchar dc;
dc = toupper(dc);

and there is nothing ambiguous about the argument.

-- 
dave (still struggling... :-)

Dave Sieber wrote:
> J C Calvarese <jcc7@cox.net> wrote:
> 
> 
>>I assume you're talking about code like this...
>>
>>import std.ctype;
>>import std.string;
>>
>>void main()
>>{
>>     char[] s = "some string";
>>     s = toupper(s);
>>     printf("%.*s\n", s);
>>}
> 
> 
> Yes, that's basically it, but I was needing toupper() on a character.
Well, I don't read minds. :) At least, not at 100% accuracy.

> 
>>If you're just using toupper once, the best thing to do is probably refer to the name of the module you want to disambiguate:
>>
>>s = std.string.toupper(s);
>>or
>>s = std.ctype.toupper(s);
> 
> 
> Cool, this works. But I'm not sure I understand why -- aren't the two functions unambiguous?
> 
> char[] toupper(char[] s)
> dchar toupper(dchar c)

If they're in the same module, yes. But I think D checks if the symbol is in different modules BEFORE it looks at parameter types. Maybe we can persuade Walter to change this.

Also, I think it'd be an improvement if the toupper is std.ctype was moved to std.string, but I suppose the idea is to have char/dchar functions in std.ctype and char[] functions in std.string.

> 
> When I import both std.string and std.ctype, even this doesn't work:
> 
> dchar dc;
> dc = toupper(dc);
> 
> and there is nothing ambiguous about the argument.
> 
Try this:

import std.ctype;
import std.string;

alias std.ctype.toupper toupper;

void main()
{
	dchar s;
	s = toupper(cast(dchar) 's');
	
	/* I don't think printf supports Unicode,
	   but this seems to be an exception. */
	printf("%c\n", s);
}

-- 
Justin
http://jcc_7.tripod.com/d/

J C Calvarese <jcc7@cox.net> wrote:

> Well, I don't read minds. :) At least, not at 100% accuracy.

What???? I am _deeply_ disappointed... <G>

> If they're in the same module, yes. But I think D checks if the symbol is in different modules BEFORE it looks at parameter types. Maybe we can persuade Walter to change this.

Perhaps we can, but it should approached with careful study. As Walter has said in the D docs, the C++ lookup rules got pretty crazy, and we'd want to avoid that. Anyway, this is only my second day programming with D, so my questions are probably representation of what a long-time C++ programmer would expect (rightly or wrongly) when moving to D.

> Also, I think it'd be an improvement if the toupper is std.ctype was moved to std.string, but I suppose the idea is to have char/dchar functions in std.ctype and char[] functions in std.string.

I suspect it was traditional, because in C toupper/tolower were found in ctype.h.

> Try this:
> 
> import std.ctype;
> import std.string;
> 
> alias std.ctype.toupper toupper;
> 
> void main()
> {
>      dchar s;
>      s = toupper(cast(dchar) 's');
> 
>      /* I don't think printf supports Unicode,
>         but this seems to be an exception. */
>      printf("%c\n", s);
> }

Well, that doesn't seem to work either, but perhaps I am still doing something wrong. Am I still thinking too much like a C++ programmer? :-)

IAC, I've solved my immediate problem with my learning code, and realize I need more study.

-- 
dave

Dave Sieber wrote:
> J C Calvarese <jcc7@cox.net> wrote: 
> 
>>Well, I don't read minds. :) At least, not at 100% accuracy.
> 
> 
> What???? I am _deeply_ disappointed... <G>
> 
>>If they're in the same module, yes. But I think D checks if the symbol is in different modules BEFORE it looks at parameter types. Maybe we can persuade Walter to change this.
> 
> Perhaps we can, but it should approached with careful study. As Walter has said in the D docs, the C++ lookup rules got pretty crazy, and we'd want to avoid that. Anyway, this is only my second day programming with D, so my questions are probably representation of what a long-time C++ programmer would expect (rightly or wrongly) when moving to D.

If Walter has already considered this issue, it's probably already set in stone. But if he hasn't considered this before it's possible that he'd change it. But I suspect that having the compiler consider the parameter types when it's looking for ambiguous symbols would be so much effort that the status quo is the way it stays.

>>Also, I think it'd be an improvement if the toupper is std.ctype was moved to std.string, but I suppose the idea is to have char/dchar functions in std.ctype and char[] functions in std.string.
> 
> 
> I suspect it was traditional, because in C toupper/tolower were found in ctype.h.

I didn't realize that. It doesn't mean that it can't change, though.

>>Try this:
>>
>>import std.ctype;
>>import std.string;
>>
>>alias std.ctype.toupper toupper;
>>
>>void main()
>>{
>>     dchar s;
>>     s = toupper(cast(dchar) 's');
>>         /* I don't think printf supports Unicode,
>>        but this seems to be an exception. */
>>     printf("%c\n", s);
>>}
> 
> 
> Well, that doesn't seem to work either, but perhaps I am still doing something wrong. Am I still thinking too much like a C++ programmer? :-)

I'm sure I don't have that problem since I don't know C++. Unfortunately, I'm probably going to have to learn it someday since there's so much cool code out there written in C++ (such as the DMD front end).

> IAC, I've solved my immediate problem with my learning code, and realize I need more study. 

-- 
Justin
http://jcc_7.tripod.com/d/

Dave Sieber schrieb:
> Cool, this works. But I'm not sure I understand why -- aren't the two functions unambiguous?

No, they are unambigous. But they are not overloads of the same symbol.

To make them overload the same symbol you can do something like

alias std.string.toupper toupper;
alias std.ctype.toupper toupper;

These make both functions overload toupper in your module's scope and you can call both directly. Additionally, if you also define your own toupper in the same module, it will also overload correctly.

I think if we need Walter to change the system, namely that not the symbols are searched within foreign scopes, but dropped temporarily into current scope, then we have to collect strong arguments. It is not impossible, but Walter is not someone who can change his mind without being really convinced.

-eye

Ilya Minkov wrote:
> Dave Sieber schrieb:
> 
>> Cool, this works. But I'm not sure I understand why -- aren't the two functions unambiguous?
> 
> 
> No, they are unambigous. But they are not overloads of the same symbol.
> 
> To make them overload the same symbol you can do something like
> 
> alias std.string.toupper toupper;
> alias std.ctype.toupper toupper;

I didn't realize that was possible. Awesome! Now that I know that, I don't think we should change the foreign scope system at all when we can work like this within the current system.

> These make both functions overload toupper in your module's scope and you can call both directly. Additionally, if you also define your own toupper in the same module, it will also overload correctly.
> 
> I think if we need Walter to change the system, namely that not the symbols are searched within foreign scopes, but dropped temporarily into current scope, then we have to collect strong arguments. It is not impossible, but Walter is not someone who can change his mind without being really convinced.

Right.

> -eye


-- 
Justin
http://jcc_7.tripod.com/d/

Dave Sieber wrote:

> c:\dmd\bin\..\src\phobos\std\string.d(502): function toupper conflicts with ctype.toupper at c:\dmd\bin\..\src\phobos\std\ctype.d(36)
> 
> Anyone else getting this?

You have to specify which one you want to use.

So long!

J C Calvarese <jcc7@cox.net> wrote:

> Ilya Minkov wrote:

>> alias std.string.toupper toupper;
>> alias std.ctype.toupper toupper;
> 
> I didn't realize that was possible. Awesome! Now that I know that, I don't think we should change the foreign scope system at all when we can work like this within the current system.

I agree, that is a good solution, and now understanding what is going on, I see why. But -- I also think that the standard library (Phobos) should work correctly "out of the box" without having to resort to any aliasing or explicit module resolutions in your code. If I were importing some foreign module from somewhere and it had a name that was identical to something else, fine. I would thank Walter for designing the language to allow this to work. But I think that whenever you see some kind of "standard" workaround that everyone has to use (such as the aliases above, or in C/C++ a macro to return the number of elements in a static array, #ifdef kludges in .h files to get around the multiple inclusion problem, etc.) it reveals a design weakness in the language, library, whatever. IMHO. In this case, I might suggest the char[] version of toupper be named differently, especially since these libraries appear to want to mirror what a C programmer knows and uses (even down to the module names themselves). If it were named strupr, for instance, it would be the name every C/C++ programmer knows and might expect, and would present no problems or surprises to anyone. It would "just work". My two cents... :-)

-- 
dave