```On Wed, 5 Jan 2005, Florian Gro? wrote:

> Mathieu Bouchard wrote:
> > On Tue, 4 Jan 2005, Florian Gro? wrote:
> > limiting? how so? can you elaborate on this?
> I think an "i" suffix is more natural for imaginary numbers than "I",
> for example.

Mathematica uses uppercase I for imaginary, and is by far the most used
algebraic manipulation software. I think a lot of mathematicians got used
to it. However, in Mathematica (AFAIK):

I is a global variable, defined to have "no value" (this is not
possible in Ruby) but only the substitution rule that I*I=-1 (Ruby
doesn't have that feature either). In Ruby, the closest that can be
done is I=Complex(0,1).

f x means f*x, and function calls have to be written like f[x].
I think even f(x) means f*x (really).

So I think it is important to be a bit more laidback in imitating the
conventions of classic math. If mathematicians had always been that
conservative, we would not even have the plus sign nowadays (which was
invented in 1540-something). Mathematica breaks a whole lot of common
notations because it is understood that those notations are optimised for
the handwriting of proofs, and become rather annoying in computer programs
(e.g. LaTeX or LyX) and... I've seen '70s/'80s math textbooks written with
typewriters. They're a hell to read, can't imagine the hell they are to
write.

> But I have to admit that this is not all that important.

But it's important to realise that it's not important, which is why I take
the time to write about it! :-)

> I guess my hesitancy to using regular Kernel methods is mostly based on
> other factors. While you were able to omit the parentheses in some of
> your examples rendering the syntax as  R"0.5"  which is already quite
> acceptable that will not work in general, R"0.5" + 0.5 would not work,
> for example and R("0.5") is and looks like a global method call.

Using my example's notation it would be Q(1,2), where Q is exactly just an
alias for Rational, and so it accepts only a pair of Integers, and not a
stringified float, for two reasons:

Using double-quotes is useless and cumbersome for cases where
the unquoted syntax is already valid (such as writing 1, writing 2,
and writing 0.5)

Using float syntax for rationals is ugly and borders on nonsense...
(and i repeat myself)

So the example R"0.5" + 0.5 is not appropriate. Please find another
example instead...

> I'm not feeling well about having these functions that would only be
> used for number literal like usage anyway in the Kernel where they would
> appear in line with other methods like "puts" and "caller".

Well, then, define them in another module and include that module
whereever you need it!!! You know, if my solutions look bad to you, but
have obvious fixes, you don't need to concentrate on my bad solutions, you
can improve my solutions and make them your own!

> Don't you feel bad explaining to a newcomer that that R() method that
> is reachable from all Objects is something the standard library
> defines to allow for easier constructing of Rationals?

No, because by then, I would have made it clear that I do not endorse all
of Ruby's features, and that I use Ruby for its advantages, not its
inconvenients. If I wanted a programming language that is free of
inconvenients or embarrassments, I would not use Ruby.

This is the kind of wisdom I learned from a Perl programmer. His name is
Larry Wall and he writes lots of useful articles. However Perl's got a bad
reputation, so a lot of people never get to learn from him what one
wouldn't learn from anyone else. For example, Dave Thomas is no more a
replacement for Larry Wall than Larry Wall is a replacement for Dave
Thomas: if I were asked which one I like better, I'd answer "both".

I wouldn't feel bad explaining R() to a newcomer. I would downplay the
importance of that fact, because I think it would be a fact that deserves
to be downplayed. However the two things I have terrible trouble
explaining to newcomers and/or outsiders, are:

a Module is the same as a Class, except when it's not.
Multiple inheritance is not called multiple, and several
words are used just to avoid saying "inherit from".

there are things (blocks) that are 100% like Procs except
they are not objects (blocks). The & argument of a method is magical
and can only contain either a proc or nil. You can only have one
block in a call, so that if you want more, you have to use procs
instead, with a different syntax.

> I'm certain that lots of Ruby's users would not be willing to do that
> for the sake of less typing. And while I can not say that
> "number_literal_R" is immediately obvious it explains its purpose
> already way better than a single letter method name ever could.

That's because you inserted the comment inside the method name. I won't be
fooled by this one. What you want to do is use the parser so that you can
have a long, descriptive method-name in the def but a short one (the
suffix) when making a call.

> I think it would also be a good idea to move it to Numeric.literal_R
> just so it does not clobber up all Objects.

You mean "clutter" and not "clobber".

> I also have a hard time seeing the syntax pollution you talked about
> in on of your earlier postings.
[...]
> I just wonder why you seem to be against this so intensively -- is it
> the "Say no by default" mentality to avoid unnecessary language
> complexity or are there other reasons?

Well, yeah, it's just that i'd rather not add any more rules to Ruby's
syntax, as it's already quite complex as it is, especially if there are
already good enough solutions elsewhere. Of course, solutions good enough
for me are not necessarily so for other people. :-/

_____________________________________________________________________
Mathieu Bouchard -=- Montr?al QC Canada -=- http://artengine.ca/matju

```