People really should be able to write code in the way that they
understand they shoulf not need to concern themselves with wrapping
their minds around a contrivance of the language they happen to be
using to get something done.  Things like requiring the use of the
ternary operator (A special form of if in c/c++) in certain situations
are just mistakes on the part of the people who created the language.

I'm very glad I bothered to bring this up since at least now I have a
workaround until such time that the defacto requirement for K&R style
indentation with respect to blocks is removed.  I doubt any of us
would think it good to disallow the use of single letter variables in
Ruby simply because the makers all happen to think that single letter
variables are bad formatting. (Which they are but as long as you keep
them to blocks they are fine in Ruby anyway.) People would be better
served encouraging people to use comments in code other people could
reasonably be expected to need or want to read rather than forcing
users to use obscure forms of some structures, or building in silly
things like syntactic indentation that expects you to judge whitespace
for the beggining and ending of  various things.
It really does not matter how neat syntactically a language is if you
do not explain what your code is doing especially in a language such
as this that does not require explicit declaration of variables as
well as support (to an extent at least.) for implicit conversion of
data types.

 These features do encourage what could very well be considered bad
programming ppractice since variables can pretty much appear anywhere
with no readily apparent indication of how they got there. (blocks)  I
cannot express how thankful I am that ruby-core documentation is
generally incredibly well written and detailed as it offsets a great
deal of the potential WTF factor that this language could produce.

I was also wondering is there a way to *not* have to write the following:

magick::fobar.blah
or simillar when using libraries?
further more what exactly is magick:: supposed to be called?


On 10/6/06, Louis J Scoras <louis.j.scoras / gmail.com> wrote:
> On 10/6/06, Jean Helou <jean.helou / gmail.com> wrote:
> > As far as I know nothing prevents you from using a semi-colon at the
> > end of your statements if you wish ...
>
> Sure you can, but that solves a different problem really.  If you want
> to continue with more than one expression per line, reach for the
> semicolon.  You see this idiom a lot when building up a hash with
> inject.
>
>     some_enumerable.inject(Hash.new(0)) {|h, i| h[i]+= 1 ; h}
>
> Since the semicolon is not required though--i.e.: an endline is a
> valid separator--you must leave the line in a place such that the
> parsing will be unambiguous.  Lines need to be broken after operators
> rather than before.  The reason you would want it the other way around
> is so that you can see what's going on in the code by scanning the
> beginning of the lines.
>
>
> --
> Lou.
>
>