Mike Gold wrote:
> Pascal was making a simulation of first-class functions in ruby.  The
> difference between lambda { } and a real first-class function is quite
> profound.

For the benefit of this duffer, could you briefly explain the 
difference? lambdas are "first-class enough" for me: I can pass them as 
function arguments, I can return them from functions, and I can create 
new instances of them which bind to different environments.

Now, having a look in Wikipedia:

"In computer science, a programming language is said to support 
first-class functions (or function literal) if it treats functions as 
first-class objects. Specifically, this means that the language supports 
constructing new functions during the execution of a program, storing 
them in data structures, passing them as arguments to other functions, 
and returning them as the values of other functions. This concept 
doesn't cover any means external to the language and program 
(metaprogramming), such as invoking a compiler or an eval function to 
create a new function."

Personally I consider Ruby lambdas to be first-class as they are.

It looks like the definition has been explicitly rigged to exclude 
functions created by eval, without really explaining why. But even so, I 
can create functions dynamically without eval, which differ by their 
binding:

  def make_incrementer(n)
    return lambda { |x| x+n }
  end

Wikipedia continues:

"These features are a necessity for the functional programming style, in 
which (for instance) the use of higher-order functions is a standard 
practice. A simple example of a higher-ordered function is the map or 
mapcar function, which takes as its arguments a function and a list, and 
returns the list formed by applying the function to each member of the 
list. For a language to support map, it must support passing a function 
as an argument."

Of course, Ruby supports the map abstraction, and the passing of 
functions (or blocks) to map, quite happily.

Now, map is just a "simple example", and perhaps Ruby supports only a 
limited subset of functionality which includes map. Can you provide a 
better example which shows how a Ruby lambda is not first-class?
-- 
Posted via http://www.ruby-forum.com/.