October 12, 2011
The following expression compiles but does not make sense.

string str = "hello" ~ 10;
assert(str == "hello\n");

Is this a useful feature or just a bug?

October 12, 2011
Cheng Wei:

> string str = "hello" ~ 10;
> assert(str == "hello\n");
> 
> Is this a useful feature or just a bug?

I'd call it trash-feature :-|

Bye,
bearophile
October 12, 2011
On Wednesday, October 12, 2011 07:08:05 Cheng Wei wrote:
> The following expression compiles but does not make sense.
> 
> string str = "hello" ~ 10;
> assert(str == "hello\n");
> 
> Is this a useful feature or just a bug?

int and dchar implicitly convert to one another for better or for worse. Personally, I'd prefer that they didn't, but that's the way that it is, so I don't believe that this is technically a bug.

- Jonathan M Davis
October 12, 2011
Jonathan M Davis:

> int and dchar implicitly convert to one another for better or for worse. Personally, I'd prefer that they didn't, but that's the way that it is, so I don't believe that this is technically a bug.

char->int is OK, but int->char is not so OK. This programs (that compiles with no errors) seems to show a possible source of bugs, so I call this a design bug, worth fixing:


void main(string[] args) {
    int x = args.length;
    string s = "hello";
    s ~= x;
}


Bye,
bearophile
October 12, 2011
On Wednesday, October 12, 2011 03:53:22 bearophile wrote:
> Jonathan M Davis:
> > int and dchar implicitly convert to one another for better or for worse. Personally, I'd prefer that they didn't, but that's the way that it is, so I don't believe that this is technically a bug.
> 
> char->int is OK, but int->char is not so OK. This programs (that compiles with no errors) seems to show a possible source of bugs, so I call this a design bug, worth fixing:
> 
> 
> void main(string[] args) {
>     int x = args.length;
>     string s = "hello";
>     s ~= x;
> }

I believe that the primary reasoning for allowing the implicit conversion between int and dchar is so that code like this

dchar c = 'a' + 7;

doesn't require a cast. So, the primary target is converting to int to dchar. Regardless, when it's come up before, Walter has been very much against changing it.

- Jonathan M Davis
October 12, 2011
Le 12/10/2011 09:53, bearophile a écrit :
> Jonathan M Davis:
>
>> int and dchar implicitly convert to one another for better or for worse.
>> Personally, I'd prefer that they didn't, but that's the way that it is, so I
>> don't believe that this is technically a bug.
>
> char->int is OK, but int->char is not so OK. This programs (that compiles with no errors) seems to show a possible source of bugs, so I call this a design bug, worth fixing:
>

In D, the conversion is implicit if the compiler can detect it is same via bound checking. Here, the compiler can deduce that the int 10 is between 10 and 10 so can be safely converted.
October 12, 2011
> I believe that the primary reasoning for allowing the implicit conversion
> between int and dchar is so that code like this
>
> dchar c = 'a' + 7;

That's a '+' though, not a '~'.

I think it shouldn't be allowed with ~ since it's misleading.
Newbies would probably expect "abc" ~ 10 to yield "abc10" rather than the odd "abc\n".
October 12, 2011
On Wed, 12 Oct 2011 09:46:57 -0400, Trass3r <un@known.com> wrote:

>> I believe that the primary reasoning for allowing the implicit conversion
>> between int and dchar is so that code like this
>>
>> dchar c = 'a' + 7;
>
> That's a '+' though, not a '~'.

Jonathan meant this better example ;)

string s = "hello";
s ~= 'a' + 7;

> I think it shouldn't be allowed with ~ since it's misleading.
> Newbies would probably expect "abc" ~ 10 to yield "abc10" rather than the odd "abc\n".

100% agree.  Requiring a cast in order to convert to dchar is a small price to pay (not that common to do arithmetic with characters) for avoiding surprising compilations.

-Steve
October 13, 2011
== Quote from Steven Schveighoffer (schveiguy@yahoo.com)'s article
> On Wed, 12 Oct 2011 09:46:57 -0400, Trass3r <un@known.com> wrote:
> >> I believe that the primary reasoning for allowing the implicit
> >> conversion
> >> between int and dchar is so that code like this
> >>
> >> dchar c = 'a' + 7;
> >
> > That's a '+' though, not a '~'.
> Jonathan meant this better example ;)
> string s = "hello";
> s ~= 'a' + 7;

It's still fine if '~' does not allow implicit casting but '+' does. 'a' + 7 -> 'h' which is already a dchar. So it can be appended to s without casting.

Now the question is how easy it is to allow implicit casting for some operators but not other operators.


> > I think it shouldn't be allowed with ~ since it's misleading. Newbies would probably expect "abc" ~ 10 to yield "abc10" rather
than
> > the odd "abc\n".
> 100% agree.  Requiring a cast in order to convert to dchar is a
small
> price to pay (not that common to do arithmetic with characters) for
> avoiding surprising compilations.
> -Steve

October 13, 2011
On Thu, 13 Oct 2011 06:57:09 -0400, Cheng Wei <rivercheng@gmail.com> wrote:

> == Quote from Steven Schveighoffer (schveiguy@yahoo.com)'s article
>> On Wed, 12 Oct 2011 09:46:57 -0400, Trass3r <un@known.com> wrote:
>> >> I believe that the primary reasoning for allowing the implicit
>> >> conversion
>> >> between int and dchar is so that code like this
>> >>
>> >> dchar c = 'a' + 7;
>> >
>> > That's a '+' though, not a '~'.
>> Jonathan meant this better example ;)
>> string s = "hello";
>> s ~= 'a' + 7;
>
> It's still fine if '~' does not allow implicit casting but '+' does.
> 'a' + 7 -> 'h' which is already a dchar. So it can be appended to s
> without casting.

A + B where the types of A and B are integral goes through integer promotion rules, inherited from C.  Like them or not, they are very unlikely to change.  This means dchar + int promotes to int, not dchar.

I think requiring a cast to go from int to dchar would be fine.  It's not a very common operation, and it clearly causes novice issues.

-Steve
« First   ‹ Prev
1 2
Top | Discussion index | About this forum | D home