For me, it was the other way around. I had a short, but pleasurable, tryst with Scheme and then discovered Ruby. Scheme is just a little too hardcore (though delightfully so) for my tastes. I’d rather just get stuff done.

Although, I do admit to wishing that Ruby was a bit closer to Scheme in the “code is data and data is code” department. That and more scheme-like lambda stuffs. I don’t like having to say:

foo = lambda do
  puts 'hello world'
end
foo.call

It’s the “foo.call” that bugs me. There’s always this naggy thing that really just wants to just say “foo”. Oh, and I hate having to use the *params trick with blocks to pass optional parameters. But that’s just me.

Who are these shadowy repackagers and why are (were) their panties in a knot?

The issue with removing the #call is how does Ruby know when you’re calling the lambda and when you’re just passing it around? Like given your example, what would bar = foo mean? Are you copying the lambda? Or assigning the lambda to foo?

Oh, I know the reasons why there’s a #call. I know it’s a wish I can’t have.

How about:

def block(&b)
    b.call
    b
  end

  foo = block do
    puts "hello world" 
  end

Actually, the real issue is that Ruby is a “Lisp-2” where Scheme is a “Lisp-1”

foo = lambda {"foo is a variable"}

def foo
 "foo is a method" 
end

foo.call
=> "foo is a variable" 

foo()
=> "foo is a method" 

Give us a link to the ruby-core thread :)

I would, but oddly enough it’s rather missing.

The discussion is available on the MARC archives, although that color scheme is kind of hard on the eyes…

One of my recent decisions was to use array = []; count = -1; (followed by an each_byte block containing) array[count] = item. This turned out to be so much faster than array += [item]. (For a solution similar to John’s btw see www.rubycentral.com/ref/ref_c_method.html)

The each_byte block has to have count += 1 followed by array[count] = item, of course!

chap, if you do not need the counting for some reason, you may also use array << item!

I still prefer scheme over ruby but you guys are very nice. Keep it up!