= Delegates = 

(also known as typesafe (function) method pointers).

A delegate is a type that safely encapsulates a method of a specific signature
(method return type and parameters). 

A reference to any method that matches the delegate's signature
can be assigned to the delegate. 

Once a delegate is assigned a method, it behaves exactly like that method 
and can be used like any other method, with parameters and 
a return value.

The type of a delegate is defined by the name of the delegate. 

In cobra, delegates are declared as "method signatures" and define a type:
e.g 
{{{
sig FunctionWithOneIntArgAndReturnsBool(i as int32) as bool
}}}

Here the delegate type name is "!FunctionWithOneIntArgAndReturnsBool"

The following is the usual set of steps in declaring a delegate type, a conforming method and instantiating and
invoking the delegate.
{{{
# The following declares a delegate (type) named Del that can 
#encapsulate a method that takes a string  as an argument and returns void:
sig Del(message as String)
...
# a method that conforms to the delegate Type
def delegateMethod(msg as String)
    Console.writeline(msg)
...
    
# Instantiate the delegate.
handler as Del = .ref delegateMethod

# invoke the delegate.
handler("Hello World");
}}}




== Grammar ==
{{{
# delegate definition
sig TYPENAME(ARGS) as TYPE

# delegate instantiation
name as SIGTYPENAME = ref METHODNAME

# delegate invocation
name        # no arg delegate
name(ARGS)
}}}


== Examples ==
{{{
class SigEG
    sig IntTest(i as int) as bool

    def tstInt( i as int) as bool is shared
        return i > 47

    def main is shared
        tester as IntTest = ref .tstInt
        assert tester(99) 
        assert not tester(3) 
}}}

{{{
# as above using an anon function
    tester as IntTest = do(i as int)
	return i > 47

    assert tester(99) 
    assert not tester(3) 

# using a lambda expression		
    tester = do(i as int) = i > 100
    assert not tester(99) 
    assert tester(103) 
}}}

== Notes ==

Type inference on delegate variables and method references is not all it could be 
so currently delegate variable definitions need a type definition.
{{{
name as SIGTYPENAME = ref METHOD
# rather than just
name = ref METHOD
}}}