Lionello Lunesu wrote:

> Also, please, arguments of the type "<x> looks like <language y> and I don't like <language y>". That's a strawman argument. I wish we'd get rid of this kind of reasoning once and for all.
> 
> L. 
> 

You like strawman arguments, don't you Lio. ;-)

I wouldn't exactly call these strawman arguments, though, unless you can show us why.  These aren't arguments at all. They're merely statements of feelings, preference, and emotion.  Strawman arguments are much more serruptitious. :-)

-JJR

David L. Davis wrote:
> In article <opsraw0fs723k2f5@nrage.netwin.co.nz>, Regan Heath says...
> 
> ..
> 
>>Who suggested 'isnot'?? I like 'isnt'.
>>
>>Regan
> 
> 
> Not sure who suggested "isnot" (it was my first choice), but now that it appears
> to be totally out of the question. So, I guess it's time for me to move into
> "isnt" camp, since that would be my next choice. Unless of course, we could
> out-smart(tm) Microsoft, and use "isknot" which is pronounced the same...but,
> just spelled differently! :))
> 
> David L.

I do not like "isnt."  Informal English contractions do not sit well with me in a formal computer language.  It looks hackish, crude, and lazy.  It looks like a mash of letters squashed together.

!is is kinda ugly but workable.  Maybe sticking with Lio's idea is not a bad idea: =!=.  Or be out with it and provide another operator "not" so that we can say "is not" like Kris mentioned.  It seems we're all pretty confused here about what we want to do.  We don't want pascali, but nonetheless, we still use some of it?  We might as well go all or nothing: "=!=" or "is not" or mabye both?

-JJR

On Tue, 24 May 2005 22:52:25 -0700, John Reimer <brk_6502@yahoo.com> wrote:
> David L. Davis wrote:
>> In article <opsraw0fs723k2f5@nrage.netwin.co.nz>, Regan Heath says...
>>  ..
>>
>>> Who suggested 'isnot'?? I like 'isnt'.
>>>
>>> Regan
>>   Not sure who suggested "isnot" (it was my first choice), but now that it appears
>> to be totally out of the question. So, I guess it's time for me to move into
>> "isnt" camp, since that would be my next choice. Unless of course, we could
>> out-smart(tm) Microsoft, and use "isknot" which is pronounced the same...but,
>> just spelled differently! :))
>>  David L.
>
> I do not like "isnt."  Informal English contractions do not sit well with me in a formal computer language.  It looks hackish, crude, and lazy.

D is not English. It doesn't have to follow the same rules. Further, not everyone programming in D even speaks/reads English. I'm all for correct English, where it matters, but IMO this is not one of those places.

> !is is kinda ugly but workable.

The mixing of punctuation and letters bothers me. Walter did say it would in fact be two tokens "!" and "is", parsed using lookahead, but to me it just looks like a logical negation of a variable called "is" (granted, that would be illegal in D..)

> Maybe sticking with Lio's idea is not a bad idea: =!=.

If we're going to keep using punctuation, why not keep "!=="?

I figured people we're bothered by the lack of symetry, "is" contains only letters, "!==" contains punctuation, and you'd not immediately know one was the opposite of the other.

> Or be out with it and provide another operator "not" so that we can say "is not" like Kris mentioned.  It seems we're all pretty confused here about what we want to do.

My impressions are:

1- We're after a shortcut for "!(a is b)".
2- Some dislike the lack of symetry between "is" and "!==".
3- Apparently "isnot" is copyrighted (or otherwise off limits).
4- Some dislike "isnt" as it isn't proper/correct english.
5- Some dislike the look of pascal, or perl, or <insert hated language here>

So, the solution apparently, has to be:
1- A shortcut
2- To change "is" to punctuation OR use letters for it's opposite
3- Not "isnot"
4- Proper english
5- Not used by pascal, perl, <insert hated language here>

How about:

"is" changes to "eq"  (as in equal)
"!==" changes to "ne" (as in not equal)

> We don't want pascali, but nonetheless, we still use some of it?  We might as well go all or nothing: "=!=" or "is not" or mabye both?

Good point, given that "!" and "is" would parse as two tokens and be interpreted using look ahead, why cant "is" "not" be done the same way? "is" would be a 'greedy' token.

Regan

On Wed, 25 May 2005 17:55:19 +1200, Regan Heath wrote:


[snip]

> My impressions are:
> 
> 1- We're after a shortcut for "!(a is b)".
> 2- Some dislike the lack of symetry between "is" and "!==".
> 3- Apparently "isnot" is copyrighted (or otherwise off limits).
> 4- Some dislike "isnt" as it isn't proper/correct english.
> 5- Some dislike the look of pascal, or perl, or <insert hated language
> here>
> 
> So, the solution apparently, has to be:
> 1- A shortcut
> 2- To change "is" to punctuation OR use letters for it's opposite
> 3- Not "isnot"
> 4- Proper english
> 5- Not used by pascal, perl, <insert hated language here>
> 
> How about:
> 
> "is" changes to "eq"  (as in equal)
> "!==" changes to "ne" (as in not equal)

Now this is a rational approach to the issue. Best option so far, IMNSHO.

-- 
Derek Parnell
Melbourne, Australia
25/05/2005 4:21:27 PM

Derek Parnell wrote:
> On Wed, 25 May 2005 17:55:19 +1200, Regan Heath wrote:

>>"is" changes to "eq"  (as in equal)
>>"!==" changes to "ne" (as in not equal)
> 
> 
> Now this is a rational approach to the issue. Best option so far, IMNSHO.
> 


I think this whole thing would be simplified greatly if these were not keywords per se, but /properties/ instead. For example, if A-Arrays were a class/struct instead of a special type, one might imagine this instead of "if (x in y)":

if (y.contains(x))
if (! y.contains(x))

or, if we must:

if (y.in(x))
if (! y.in(x))

Isn't that more effective? I sure think so; and it reduces the keyword count. Of course, given that they are part of the core language, Walter could easily make AAs operate like this instead of using 'in' ...

Similarly:

if (x.is(y))
if (! x.is(y))

Which also reduces the keyword count, and fits well with the basic language syntax.

For those who find the parens() to be overtly verbose, one might imagine them being implied for single argument properties?

if (y.contains x)
if (! y.contains x)

if (x.is y)
if (! x.is y)


------------

As discussed several times before ~ I'd really, really like to see a means of adding properties to the native types. Those of you who like the funky syntax associated with array-arguments would have a field-day with adding properties instead (a la C#, as Andy once pointed out); far more powerful. I mention this because such a feature could be taken advantage of in these cases, rather than clutter the core language with additional special-case keywords and/or symbolic compromises.

- Kris

kris wrote:
> Derek Parnell wrote:
> 
>> On Wed, 25 May 2005 17:55:19 +1200, Regan Heath wrote:
> 
> 
>>> "is" changes to "eq"  (as in equal)
>>> "!==" changes to "ne" (as in not equal)
>>
>>
>>
>> Now this is a rational approach to the issue. Best option so far, IMNSHO.
>>
> 
> 
> I think this whole thing would be simplified greatly if these were not keywords per se, but /properties/ instead. For example, if A-Arrays were a class/struct instead of a special type, one might imagine this instead of "if (x in y)":
> 
> if (y.contains(x))
> if (! y.contains(x))
> 
> or, if we must:
> 
> if (y.in(x))
> if (! y.in(x))
> 
> Isn't that more effective? I sure think so; and it reduces the keyword count. Of course, given that they are part of the core language, Walter could easily make AAs operate like this instead of using 'in' ...
> 
> Similarly:
> 
> if (x.is(y))
> if (! x.is(y))
> 
> Which also reduces the keyword count, and fits well with the basic language syntax.
> 
> For those who find the parens() to be overtly verbose, one might imagine them being implied for single argument properties?
> 
> if (y.contains x)
> if (! y.contains x)
> 
> if (x.is y)
> if (! x.is y)
>

I think this would be best. And if "cast" operator will be replaced by .as() property everything will look solid.

> 
> ------------
> 
> As discussed several times before ~ I'd really, really like to see a means of adding properties to the native types. Those of you who like the funky syntax associated with array-arguments would have a field-day with adding properties instead (a la C#, as Andy once pointed out); far more powerful. I mention this because such a feature could be taken advantage of in these cases, rather than clutter the core language with additional special-case keywords and/or symbolic compromises.
> 
> - Kris

Hi John!

> You like strawman arguments, don't you Lio. ;-)

They're my favorite :-)

> I wouldn't exactly call these strawman arguments, though, unless you can show us why.  These aren't arguments at all. They're merely statements of feelings, preference, and emotion.  Strawman arguments are much more serruptitious. :-)

I've followed some philosophy course a while ago, but I really can't remember all these different names for common argumentations.

Strawman was something like: instead of attacking position X, you claim that Y is like X and attack Y instead.

The arguments used against Y might have nothing to do with the similarity between X and Y, and therefore would never apply to X.

So I think this is indeed strawman: "This looks like basic and basic is bad". Anyway, I've simplified it, but the construct is clear :-)

L.

Thank you, Walter, for this clear overview of arguments for "!is".

I wish you'd posted these in the first place :-)

L.

On Wed, 25 May 2005 00:20:47 -0700, kris wrote:

[snip]
> 
> Similarly:
> 
> if (x.is(y))
> if (! x.is(y))

Fails if x is null though.

-- 
Derek Parnell
Melbourne, Australia
25/05/2005 6:57:43 PM

Why don't we add "greater than" and "less than" too, then?

-[Unknown]