[ruby-talk:01358] Re: Say hi (bis)

Hi,

In message "[ruby-talk:01354] Say hi (bis)"
    on 00/02/15, Pixel <[e-mail]> writes:
|--------------------------------------------------------------------------------
|bad points:
|
|--- `||' and `or' treats everything except nil as true
|    (so 0 || 4 == 0,  "" || 4 == "")

It is for performance and unambiguity reason.

|-- ?? no explicit references (aka \ in perl)

In Ruby, everything can be considered as reference, so that \ is
needless.

|-- ?? no slices

 a=[1,2,3]
 a[1,2]  #=> [2,3]
 a[1..2] #=> [1,2]

|-- ?? can't redefine a function

you can.

|-- no overloading (can be achieved manually, but hell...)

I don't know what you mean.  By argument number and types?

|-- no verification of #vars for blocks

Indeed.

|- no flattening of lists (eg: trans(x1,y1,x2,y2) can't be called with trans(*f,*g))
|  (only for blocks)

trans(*(f+g)) will work.

|- map missing for arrays (is .dup.filter ?)

We call them collect:

 [1,2,3].collect{|x| x*2} #=> [2,4,6]

|- hash are real hash -> can't keep order (maybe a Vector would be nice (also more economic))

hash is real hash even in Perl (see each).

  foo(a=>b, c=>d)

in Perl is just another form of

  foo(a, b, c, d)

so, list, not hash is passed to foo.

|- you have to initialize before doing +=

Explicit initialization is good thing I think.

You can avoid them by

  def <<nil
    def +(other)
      other
    end
  end

|- no named arguments (see python)

It's planned.

|- doc not as good as perl's :ppp

I have to admit, project is underway.  Help welcome.

|- error messages not explicit

Could you help make them explicit?

|- each_index useless? why not passing both the index and the value (usefull!)

use each_with_index.  In general, methods described under Enumerable
are useful, e.g. collect, select, each_with_index.

|/ in hash, { a => 1 } not allowed, must be { 'a' => 1 }

Perlish. :-)
There's no unquote identifier as string in Ruby.

|/ no implicit transformation string <=> num

It used to.  But changed because it tends to pretend the type problem
to be found.

							matz.