Implicit enum conversions are a stupid PITA

[grauzone]

Walter Bright wrote:
> Nick Sabalausky wrote:
>> To put it simply, I agree with this even on mere principle. I'm 
>> convinced that the current D behavior is a blatant violation of 
>> strong-typing and smacks way too much of C's so-called "type system".
> 
> You're certainly not the first to feel this way about implicit 
> conversions. Niklaus Wirth did the same, and designed Pascal with no 
> implicit conversions. You had to do an explicit cast each time.
> 
> Man, what a royal pain in the ass that makes coding in Pascal. 
> Straightforward coding, like converting a string of digits to an 
> integer, becomes a mess of casts. Even worse, casts are a blunt 
> instrument that *destroys* type checking (that wasn't so much of a 
> problem with Pascal with its stone age abstract types, but it would be 
> killer for D).

That's funny that you're saying this. Casts are totally messed up in D. 
Some casts do safe operations (casts between objects and interfaces), 
some are absolutely ridiculous and only useful in low level situations 
(casting array slices), some are safe whenever the compiler feels like 
it (array casts of array literals versus array slices), and some 
fundamentally break other language features, even accidentally (immutable).

casts are easily grepable, but you never know what a specific cast 
actually does. Think about what this means for generic templated code.

In summary, I'd say casting rules in D are the worst spawn of hell.

I mean, that's ok, it doesn't exactly make D useless. And you can always 
introduce your own safe (exe bloating, sigh) casting template functions. 
But I still find it funny that you say this.

> Implicit integral conversions are not without problems, but when I found 
> C I threw Pascal under the nearest bus and never wrote a line in it 
> again. The taste was so bad, I refused to even look at Modula II and its 
> failed successors.

For your information, programming in Delphi (modern Pascal dialect) was 
quite a joy. It combined the advantages of the low level programming of 
C (pointers, inline assembler), was safer than C, and included a sane 
object model similar to Java/C#. Sounds familiar?

(Yeah, the template fetishists must have been very unhappy with it.)

I really don't understand why you're bashing Pascal at large. You must 
have had only experience with early Pascal dialects... and then never 
looked at anything that smelled like Pascal... and this as a language 
designer??

> D has 12 integral types. Disabling implicit integral conversions would 
> make it unbearable to use.


PS: while you guys are talking about new "absolutely necessary" language 
features, people new to D are despairing to get a working D installation 
and *trying* to use external libraries from dsource (that kind of 
struggling really isn't nice to watch), and people "old" to D are 
desparing over compiler regressions and random bugs that have global 
effects on middle-sized to large codebases (circular dependency and 
optlink bugs come to mind). The situation is slowly improving, but too 
slow and problems *never* get completely eliminated.

/rant
Well, I'm out of here.