That changes the entire scope of the issue.

http://boo.codehaus.org/Generator+Expressions

return array(double, double.Parse for n in numbers)

try this:

value = array(double.Parse(value) for value in ("1.0", "3.15"))[-1]

(I can't make "def Apply(function as callable, value as duck):
/* manipulate value here */
return function(value)" use anything that is overloaded, for instance).

I don't suppose there is a way to delay looking up overloaded functions until they've been invoked?

To change it to an ambiguous reference error instead, change line 2266 of ProcessMethodBodies from this:

if (NodeType.ReferenceExpression == node.NodeType &&

to this:

if (node is ReferenceExpression &&

This fixes the problem because double.Parse for example is a memberreferenceexpression, which is a subclass of referenceexpression.

So this version makes exceptions for events:

if (node is ReferenceExpression &&
!AstUtil.IsTargetOfMethodInvocation(node) &&
!(EntityType.Field == amb.Entities[0].EntityType &&
EntityType.Event == amb.Entities[1].EntityType))

def __parse(*args): //method created by compiler
l = len(args)
if l==1 and args[0] isa string:
return double.Parse(cast(string,args[0]))
elif l==2 and args[0] isa string and args[1] isa System.IFormatProvider:
return double.Parse(cast(string,args[0]),cast(System.IFormatProvider,args[1]))
elif l==2 and args[0] isa string and args[1] isa System.Globalization.NumberStyles:
return double.Parse(cast(string,args[0]),cast(System.Globalization.NumberStyles,args[1]))

d = __parse //replacement for double.Parse

print d("34.3")

class A:
def test():
print "test1"
def test(a as int):
print "test2", a
def test(a as int, b as int):
print "test3", a, b

//This is created automatically by the compiler:
class _A_test_Callable(ICallable):
_inst as A
def constructor(inst as A):
_inst = inst
def Call(*args):
l = len(args)
if l==0:
_inst.test()
elif l==1 and args[0] isa int:
_inst.test(cast(int,args[0]))
elif l==2 and args[0] isa int and args[1] isa int:
_inst.test(cast(int,args[0]),cast(int,args[1]))
else:
raise "invalid arguments"

a = A()
//c = a.test //won't work, boo-250
c = _A_test_Callable(a) //instead compiler inserts this as replacement for "a.test"
c(3,4)
c(1)
c()

class Foo:
def bar(a as int):
print a
def bar(a as string);
print a

a = functionReturningObject()
f = Foo()
// today
(f as duck).bar(a)

// with your proposal
(f.bar)(a)

interesting...

class A:
def test():
print "test1"
return 1
def test(a as int):
print "test2", a
return 2
def test(a as int, b as int):
print "test3", a, b
return 3

//This class is created automatically by the compiler:
final class _A_test:
_inst as A
def constructor(inst as A):
_inst = inst
def Invoke(*args) as int:
l = len(args)
if l==0:
return _inst.test()
elif l==1 and args[0] isa int:
return _inst.test(cast(int,args[0]))
elif l==2 and args[0] isa int and args[1] isa int:
return _inst.test(cast(int,args[0]),cast(int,args[1]))
else:
raise "invalid arguments"

a = A()
//c = a.test //won't work, boo-250
c = _A_test(a).Invoke
print c(3,4) * 2 //I do a "*2" here to check that return type is preserved
print c(1) * 2
print c() * 2