John Reimer wrote:
> Ah!
> 
> "isnt" be ugly and I'm stickin' to it! ;-)
> 
> <runs away covering eyes and ears>
> 
> -JJR


"isnt" !be ugly. "!is" be ugly. No, wait... "!be" be ugly... omg :o


-- 
Tomasz Stachowiak  /+ a.k.a. h3r3tic +/

Tom S wrote:
> John Reimer wrote:
> 
>> Ah!
>>
>> "isnt" be ugly and I'm stickin' to it! ;-)
>>
>> <runs away covering eyes and ears>
>>
>> -JJR
> 
> "isnt" !be ugly. "!is" be ugly. No, wait... "!be" be ugly... omg :o

One should note, however, that, (by definition)
	"!is" !is ugly
however, I respect your opinion if you say that you think that
	"!is" == ugly

Tom S wrote:
> John Reimer wrote:
> 
>> Ah!
>>
>> "isnt" be ugly and I'm stickin' to it! ;-)
>>
>> <runs away covering eyes and ears>
>>
>> -JJR
> 
> 
> 
> "isnt" !be ugly. "!is" be ugly. No, wait... "!be" be ugly... omg :o
> 
> 

LOL!

Remember D "is not" English... so it does not matter what "is" or "is not" ugly! <-- (exclamation as an exclamation).  It does matter, though, what "is" or "is not" a strawman (tip of the hat to Lio). :-D

Trust the d newsgroup to run a serious topic into the ground. He he...

-JJR

(See? Was not the "is not" soooo clear?)

In article <d725oo$2tsj$1@digitaldaemon.com>, Russ Lewis says...
>
>Tom S wrote:
>> John Reimer wrote:
>> 
>>> Ah!
>>>
>>> "isnt" be ugly and I'm stickin' to it! ;-)
>>>
>>> <runs away covering eyes and ears>
>>>
>>> -JJR
>> 
>> "isnt" !be ugly. "!is" be ugly. No, wait... "!be" be ugly... omg :o
>
>One should note, however, that, (by definition)
>	"!is" !is ugly
>however, I respect your opinion if you say that you think that
>	"!is" == ugly

Just make sure that ugly !is null first.

- EricAnderton at yahoo

"Kris" <fu@bar.com> wrote in message news:d6tgiu$23a5$1@digitaldaemon.com...
> !is does have some kind of Yoda feel to it ... for better or worse

No, I think any Yoda-esque language would have to be written in RPN.  ;)

Actually, it's not a logical argument for why "isnot" is bad, it's an explanation of why "I don't like it".

I don't like languages that use words for everything, like pascal .. when I took a pascal course at Uni, it was very hard for me to maintain and debug my code, because everything was so cluttered with words. no clear distinction between different functions .. no clear lines/borders .. you know. not like C languages, where { and } and proper indentation makes everything look nice.

having an "isnot" kinda reminds me of these languages, which makes me feel bad about D. so I'd hate it if D has an "isnot" operator.

maybe now it's clear why this is not a "Strawman" argument.

btw, you shouldn't apply these logical rules strictly, because when we speak, we don't follow a strcit mathematical rule.
maybe a statement looks like a fallacy, but it actually isn't. like the ones I just explained.
and maybe a statement doesn't look like a fallacy, buty it actually is.

It's not the written word, it's the logical flow.

You don't have to say "assume x, therefor x" to be using circular logic.

you could simply say "x is true because it's true".
or, if two statements, x and y have the same meaning, you could say"
"x is true because y is true".

I once was kinda objecting against someone for using what I thought was circular logic, but he said
"How's that circular? circular is when you say "assume x, therefor x", but I wasn't saying that!!!"

But you know what, if you try to apply these like that, most of the time it won't work.

If you can't logically see the fallacy in your mind (regardless of the structure and the wording of the argument), then it's probably not a fallacy.

Lionello Lunesu wrote:
> 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. 
> 
> 

>There are a couple other arguments against isnot:
>
>1) The !in application has been brought up. I don't think innot is in the cards.

What about notin? OK this one is hard to "parse" by the eyes. notIn, not_in, ... hmmm

>2) ! is the C language family term for "not".
>
>3) Microsoft has patented "isnot" as an operator. While I feel this patent is absurd and would not stand in court, I have neither the resources nor the desire to go court about it.

AFAIK it'ts only patented for BASIC-like languages. I'm not sure if D is one of those.

Matthias Becker wrote:

>>There are a couple other arguments against isnot:
>>
>>1) The !in application has been brought up. I don't think innot is in the cards.
> 
> What about notin? OK this one is hard to "parse" by the eyes. notIn, not_in, ... hmmm

That should be nothin'


Lars Ivar Igesund

>C++ has "alternate tokens" for many operators, and the best that could be said for it is it seemed a good idea at the time. The alternate tokens are essentially never used, to the point where few even realize they are in the language. Then they get tripped up by them.

I allways use and and or instead of these cryptic && and || ... what ever you want to call this crap.

Best ever.
"kris" <fu@bar.org> ??????:d718k6$1gll$1@digitaldaemon.com...
> 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