From: pixel_@...
Date: 2000-02-15T14:24:34+01:00
Subject: [ruby-talk:01381] Re: Say hi (bis)

matz@netlab.co.jp (Yukihiro Matsumoto) writes:

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

oups, sorry it should have been (0 || 4) == 0,  ("" || 4) == ""

> 
> It is for performance and unambiguity reason.

i still find it a moot point:
- either 0 || 4 should return true (C behaviour)
- either 0 || 4 should return 4 (python and perl behaviour)
- either 0 || 4 should raise "undefined method `||' for 0''
(by the way can you redefine `||' ?) (ML family behaviour)

tis the first time i see 0 || 4 returning 0, kinda weird.

of course the python/perl behaviour is maybe less orthogonal as special cases
are: [] || 1, "" || 1 and 0 || 1 all gives 1

> 
> |-- ?? no explicit references (aka \ in perl)
> 
> In Ruby, everything can be considered as reference, so that \ is
> needless.

yeah, i had in mind things like my $p = \{}; my $pp = \$p;  which i did use in
perl, but seems like it can be achieved nicely with an object, forget it :)

one other thing for which it was missing is giving a function instead of a
block, eg:  

def f(n); [n,n+1]; end; 
#l.collect \f 
  #instead of 
l.collect{|n| f(n)}

> 
> |-- ?? no slices
> 
>  a=[1,2,3]
>  a[1,2]  #=> [2,3]
>  a[1..2] #=> [1,2]

i was thinking of hashes, some kind of extension to method fetch:

class Hash
  def [](*l)
    l = l[0] if l.length == 1 && l[0].type == Range
    l.collect{|i| fetch(i) }
  end
end

also interesting would []=

> 
> |-- ?? can't redefine a function
> 
> you can.

i was thinking of:

# !warning! perl here
sub f { 1 }
{  
  my $f = \&f;
  *f = sub { print "f called\n"; goto &f };
}

maybe subclassing should be the solution?


> 
> |-- no overloading (can be achieved manually, but hell...)
> 
> I don't know what you mean.  By argument number and types? 

by argument number, only simple sugar needed. But i guess it would interfere
with method redefinition, and wouldn't be easy to add...

by type could be cool, but needs more sugar...

def f(Fixnum i); i + 1; end
def f(String i); i + "\n"; end

[...]

> |- 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.

cool :)

[...]

> |- 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

i don't quite understand that one :(

i'd have said:

class NilClass
  def +(other); other; end
end

but anyway, that's only += that i would like to work, not full `+'

> 
> |- no named arguments (see python)
> 
> It's planned.

:)


[...]

> |- 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.

ok, still missing collect_with_index :)