Pointers

Local d:Delegate = New Delegate(object, method)
d(1, 2, 3) ' calls object.method(1, 2, 3)

Class MyClass
    Method CallWithADelegate
        Local myDelegate:= AddressOf Self.MyMethod
        myDelegate.Invoke(12,"hello world")
    End
    MyMethod(value:Int, data:String)
        Print value + " " + data
    End
End

Class EventHandler<T>
    Field listeners:List<Delegate(sender:Object, arguments:T)>
    Method RaiseEvent(sender:Object, arguments:T)
        For each del:=listeners
            del.Invoke(sender,arguments)
        End
End Class

Class MyClassThatRaisesAnEvent
    Field ImDone:EventHandler<Bool>
    Method DoStuff()
        ...
        ...
        ImDone.RaiseEvent(Self, True)
    End
End

Class MyClassThatListensToAnEvent
    Field instance:=New MyClassThatRaisesAnEvent
    Method New
        instance.ImDone.listeners.Add(AddressOf Me.InstanceHasDoneStuff)
    End
    Method InstanceHasDoneStuff(sender:Object, success:Bool)
        ....
        Print "Listening to instance! It's done it's stuff!"
    End
End

Class EventHandler<T>

	Field listeners:=New List<Void(Object,T)>
    
	Method RaiseEvent( sender:Object,arguments:T )
		For Local del:=Eachin listeners
    			del( sender,arguments )
    		Next
    	End
    	
End

Class MyClassThatRaisesAnEvent

    Field ImDone:=New EventHandler<Bool>
    
    Method DoStuff()
    		Print "thinking..."
		ImDone.RaiseEvent( Self,True )
    End

End

Class MyClassThatListensToAnEvent

	Field instance:=New MyClassThatRaisesAnEvent
	
	Method New()
		instance.ImDone.listeners.AddLast( InstanceHasDoneStuff )
	End

	Method InstanceHasDoneStuff:Void( sender:Object,success:Bool )
		Print "Listening to instance! It's done it's stuff!"
    End
End

Class EventHandler<T>

	Alias Listener:Void( Object,T )  'kind of like c# delegate? Listener is a 'type'.
	
	Field listeners:=New List<Listener>
...etc...

Action MyDelegate:Bool(param1:String, param2:String) '--> Defines a method signature here, using Action 

Function Update:MyDelegate(parameter1:Int) '--> Define a function with an integer parameter, and this function returns a function that returns an Bool, and has 2 string parameters, because it returns a MyDelegate type

Field myCallback:MyDelegate = me.StuffDone '--> Where StuffDone is a method that returns a Bool and has 2 string parameters
If myCallback("Hello ", "world")
    DoStuff...
End If

Function Update:&Bool(param1:String, param2:String)(parameter1:Int)

Field myPointer:&Bool(param1:String, param2:String)
...
myPointer = me.DoSomething
If myPointer("hello ", "world") = True Then
    DoStuff
EndIf

Action MyIntegerFunction:Int() '-> That's the "delegate" signature definition.
...
Function Update:MyIntegerFunction() '->That's usage of that definition.

Action MyIntegerFunction:Int() '-> That's the "delegate" signature definition.
...
Function Update:MyIntegerFunction() '->That's usage of that definition.

alias RetType1:void(int,int)
alias RetType2:int
alias RetType3:List<Actor>
function func1:RetType1()   'returns a void(int,int) function
function func2:RetType2()   'returns an int
function func3:RetType3()   'returns a List<Actor>

Class Foo
	Method Bar:Int(str:String)
		Print str
		Return 1
	End
End

' instance of class
Local inst:Foo = New Foo

' instantiate method pointer passing the object and a pointer to its method
Local mp:MethodPtr<Foo,Int(String)> = New MethodPtr<>(inst, Foo.Bar)

' execute the method pointer (prints "blah" and 1)
Print mp("blah")

' essentially the same as: Print inst.Bar("blah")

class C
   field t:=10
   method test:void()
      print t
   next
end

function main:void()
   local c:=New C
   local f:void()=c.test   'Note: "c.test" is the 'tuple' you're after...
   f()
end

local f:void()=c.test   'Note: "c.test" is the 'tuple' you're after...
f()

class C
   field t:=10

   method test:void()
      print t
   end

   method s:int()
      return 2
   end
end

function func:void()
   print "func()"
end

function l:int()
   return 1
end


function main:void()
   local h:void()
   local i:int, j:int
   local k:int

   local c:=New C

   local f:void()=c.test   ' Note: "c.test" is the 'tuple' you're after...
   f()

   local g:void()=func     ' function pointers look exactly like method pointers?
   g()

   ' Without actually seeing the definition of h:void(),
   ' it's hard to guess what the following line does:

   h = func   ' this assigns a pointer-to-func to h,
              ' but in MonkeyX this could also be read
              ' as a function call (because parenthesis is not required),
              ' and it could as well be a variable assignment
   i = j
   k = l
end

h = @func()            ' clearly a function pointer
h = addressOf func()   ' clearly a function pointer
i = j                  ' clearly 2 variables
i = c.t                ' clearly 2 variables
k = c.s()              ' clearly a method   call
k = l()                ' clearly a function call

class C
   method test:int()
      return 1
   end
end

function test:int()
   return 2
end

function main:void()
   local x:int()   ' function variable / method variable
   local y:int     ' int variable

   local c:=New C()

   x = c.test()  ' assign function variable / method variable
   y = c.test()  ' direct   method call
   y = x()       ' indirect method call

   x = test()    ' assign function variable
   y = test()    ' direct   function call
   y = x()       ' indirect function call
end

class C
   method test:int()
      return 1
   end
end

function test:int()
   return 2
end

function main:void()
   local x:int()   ' function variable / method variable
   local y:int     ' int variable

   local c:=New C()

   x = c.test    ' assign function variable / method variable
   y = c.test()  ' direct   method call
   y = x()       ' indirect method call

   x = test      ' assign function variable
   y = test()    ' direct   function call
   y = x()       ' indirect function call
end

//This is ANSI C code reference! No monkey code here.

void * ->  Generic pointer type
NULL ->  Null pointer (GC panic in monkey?)
type *name ->  Declare pointer to type
type *f() ->  Declare function returning pointer to type
type (*pf)() ->  Declare pointer to function returning type
*pointer ->  Object pointed to by pointer
&name ->  Address of object name
pointer -> the pointer itself (is more or less an int)
pointer=5000 ->generate a warning:initialization makes pointer from integer without a cast

myObject.X()+=1

Function Whatever:Int(param1:String)

Field myFunctionPointer:=Whatever

Method Position:Int() Property
Method Position:Void(value:int) Property

myInstance.Position() = 45  'This looks very weird
Print "current position is " + myInstance.Position() 'That's weird too, makes it look like a method
meInstance.Position()+=5 'This looks syntactly very weird.

Class C
   Property Foo:Int
      Field foo:int   'can be accessed ONLY by members of this class via Foo.foo
      Getter
         Return foo
      Setter
         foo=value
   End
End 

Class MyClass
Private
  Local _a:Int
Public
  Method A:Int() Property
    Return _a
  End
  Method A:Void(value:Int) Property
    _a = value
  End 
End Class

Function Main:Int()
  Local Foo:=New MyClass()

  Foo.A = 42   'Notice no parenthesis to call member A
  Print (Foo.A)  
End 

Class Foo Final
Private
	' singleton instance
	Global instance:Foo
	
	' private constructor to prevent external instantiation
	Method New(); End
	
Public
	' static property to auto-create the singleton
	Function Instance:Foo() Property
		If Not instance Then instance = New Foo
		Return instance
	End
	
	Method Hello:Int()
		Return 10
	End
	' dragons be here
End

Function Main()
	' as a property
	Foo.Instance.Hello()
	
	' not as a property
	Foo.Instance().Hello()
End