Given

x = proc {|a| a * 2}
[1,2,3].fancy_map(x)

you'd have to have

module Enumerable
  def fancy_map(x)
    result = []
    each do |element|
      result << x.call(element)
    end
    result
  end
end

that in of itself is fairly innocuous. but what about Array.new ?

There's three forms of Array.new currently:

Array.new(size=0, obj=nil)
Array.new(array)
Array.new(size) {|index| block }

For the purposes of this discussion, we don't have to worry about
Array.new() or Array.new(existing_array). Under the current syntax, we
can do the following:

x = proc {|a| a * 2}
Array.new(3, "close to deadline") # Works, gives ["close to deadline",
"close to deadline", "close to deadline"]
Array.new(3, &x) # Works, gives [0, 2, 4]
Array.new(3, x) # Less common but works, gives [a_proc_proc_here,
a_proc_proc_there, here_a_proc_there_a_proc_everywhere_a_proc_proc]

But what'd happen if you banned the lambda? You'd either not be able
to do the equivalent of Array.new(3, &x), or you wouldn't be able to
do the equivalent of Array.new(3, x)

I'm not sure what approach Haskell takes with this, however. Perhaps
it manages to handle this issue easily.