Yukihiro Matsumoto wrote:
>Why not go with lambda(arg-list) { body } or fun(arg-list) { body } >or def(arg-list) { body } then? I think that the syntax would point >out that this is more than a method that turns a block into an object >and I think that it would be a simple solution.
Introducing a new reserved word possibly break existing code. Besides
that, there's no good candidate for a new keyword: lambda is too
awkward, def is not sufficient since we don't define anything here,
and I expect the name fun is used everywhere as local variable names.
Should be okay as long as it isn't used as a method name. The 1.9 () on local variables change was undone after all, right?
Having fun as a method name sounds bad. Same as having method1, method2 etc.. It could have been used as an accessor, though, but I think self.fun would be save to do as well.
I'm not sure I agree with lambda being too awkward. It would be awkward if we didn't also have blocks.
And JavaScript uses function and C# delegate both of which are more awkward than lambda.
Of course there is also Perl's sub.
def might not totally fit (it doesn't bind anything to a name), but it might still be the best choice if no new semi-keywords should be introduced. There's also undef, of course, but that is a more evil choice. 
"->" might appear weird at first. But it doesn't break any code.
Pure addition to the current syntax. And it's short enough to
encourage functional programming. The last one is my optimistic
estimation. There's an opposite possibility that it would be used
only to obfuscate code.
I know that Huffman encoding is better, but I think it does not take into account that human beings are better at remembering words than symbols. OTOH symbols usually stick out more visually, but I don't think I consider that a good thing in the case of lambdas.
(->(a, b) { a + b }).call
{1: ->(a, b) { puts "Hello World" }}
foo(bar: ->(a, b) { a * b }, qux: ->(str) { str.reverse })
funs = [->(a, b) { a - b }, ->(a, b) { a + b}]
funs = [
->(a, b) { a - b },
->(a, b) { a + b }
]
def adder(a)
return ->(b) { a + b }
end
adder = ->(a) do
->(b) { a + b }
end
search_fun = ->(x: 0, y: 0, width: @width, height: @height, type:
Types.All, limit: @objects.size, skip: 0, destructive: false,
&block) do
block ||= ->(object) { true }
found =
pos = 0
@objects.reject! do |object|
if object.x.between?(x, x + width) and
object.y.between?(y, y + height) and
type & object.type != 0 and
block.call(object)
then
pos += 1
if pos >= skip and pos < limit + skip
found << object
destructive
end
end
end
found
end
fun(a, b) { a + b }.call
{1: fun(a, b) { puts "Hello World" }}
foo(bar: fun(a, b) { a * b }, qux: fun(str) { str.reverse })
funs = [fun(a, b) { a - b }, fun(a, b) { a + b }]
funs = [
fun(a, b) { a - b },
fun(a, b) { a + b }
]
def adder(a)
return fun(b) { a + b }
end
adder = fun(a) do
fun(b) { a + b }
end
search_fun = fun(x: 0, y: 0, width: @width, height: @height, type:
Types.All, limit: @objects.size, skip: 0, destructive: false,
&block) do
block ||= fun(object) { true }
found =
pos = 0
@objects.reject! do |object|
if object.x.between?(x, x + width) and
object.y.between?(y, y + height) and
type & object.type != 0 and
block.call(object)
then
pos += 1
break if pos >= limit + skip
if pos >= skip then
found << object
destructive
end
end
end
found
end
