It's 'match', not 'identically equal to'. The problem is that you want it to mean 'identical', but it doesn't.
For years I have made the same argument you are making. I have been ignored. I have come to the conclusion that I was wrong. (But I still have an improvement to suggest below.) There are a number of cases where the interpreter treats all empty operands as identical. It is a good thing to have a primitive that can calculate that way. The biggest defect in having only -: is when the operands are boxed, and you need to test for exact identity all through the boxing levels. That is a pain. Suggestion: Why not define dyad ~. to mean 'identicalto', in rank, shape, value, AND TYPE (numeric/literal/symbol). That would solve the problem of detecting deep equality, and also plug the gap in the language, where currently there is no primitive to tell whether two nouns are identical. Henry Rich June Kim wrote: > I like weak-typing and see its advantages. > > Regardless of that, when two things match each other, it seems natural > they are replaceable. But in this case, they are not and they behave > differently(the results do not match) on "take". The programmer could > make some mistakes from this. > > > On Wed, May 27, 2009 at 10:23 PM, Devon McCormick <[email protected]> wrote: >> Mr. Kim - >> >> I disagree. A language like J benefits tremendously from weak-typing and >> the equivalence of empty arrays is an outcome of this, just like the >> numerical equivalence of other objects which differ internally, e.g. >> >> datatype -.1 >> boolean >> datatype 1.1-1.1 >> floating >> (-.1)-:1.1-1.1 >> 1 >> >> Obviously, we have a simple way to get at "internal" information, like >> type. However, it's much more useful to hide internal differences like that >> for comparison purposes. In my view, the preference of many computer >> scientists for strong-typing is misguided because, as a practical matter, it >> complicates things unnecessarily. >> >> Regards, >> >> Devon >> >> On Wed, May 27, 2009 at 4:25 AM, June Kim <[email protected]> wrote: >> >>> '' ;&datatype I.0 >>> +-------+-------+ >>> |literal|integer| >>> +-------+-------+ >>> >>> It seems like there are different emptiness for every datatype but >>> they all match same. I think it's more natural they don't match. >>> >>> On Wed, May 27, 2009 at 5:08 PM, June Kim <[email protected]> wrote: >>>> ''-: I. 0 >>>> 1 >>>> {. '' >>>> >>>> {. I.0 >>>> 0 >>>> >>>> Shouldn't '' -:&{. I.0 be true, given ''-:I.0? >>>> >>> ---------------------------------------------------------------------- >>> For information about J forums see http://www.jsoftware.com/forums.htm >>> >> >> >> -- >> Devon McCormick, CFA >> ^me^ at acm. >> org is my >> preferred e-mail >> ---------------------------------------------------------------------- >> For information about J forums see http://www.jsoftware.com/forums.htm >> > ---------------------------------------------------------------------- > For information about J forums see http://www.jsoftware.com/forums.htm ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
