Language features

class List<T>
   class Node
      field succ:Node
      field pred:Node
      field data:T
   end
   field head:Node
end

function fun1:void()
   class C
   end
   function fun2:void( c:C )
   end
   local c:=new C
   func2( c )
end

function Min<T>:T( x:T,y:T )
   if x<y return x else return y
end

function Main()
   print Min( 10,20 )
   print Min( "hello","there" )
end

function NegateValue:float( value:float )
   return -value
end

function ProcessValue:float( value:float,process:float( value:float ) )
   return process( value )
end

function Main:void()
   print ProcessValue( 10.0,NegateValue )
end

alias ValueProcessor:float(value:float)

function NegateValue:float( value:float )
   return -value
end

function ProcessValue:float( value:float,process:ValueProcessor )
   return process( value )
end

function Main:void()
   print ProcessValue( 10.0,NegateValue )
end

class ValueScaler
   field scale:float

   method new( scale:float )
      self.scale=scale
   end
   
   method ScaleValue:float( value:float )
      return value*scale
   end
end

function ProcessValue:float( value:float,process:float( value:float ) )
   return process( value )
end

function Main:void()
   local scaler:=new ValueScaler( 3 )
   print ProcessValue( 10.0,scaler.ScaleValue )
end

alias GizmoModifiedListener:void( Gizmo )

class Gizmo
   field OnModified:GizmoModifiedListener  'signal

   method Modify:void()
      OnModified self
   end
end

function GizmoModified:void( gizmo:Gizmo )   'slot
   print "Gizmo modified!"
end

function Main:void()
   local gizmo:=new Gizmo
   gizmo.OnModified=GizmoModified
   gizmo.Modify
end

class List<T>
   class Node
      field succ:Node
      field pred:Node
      field data:T
   end
   field head:Node
end

Class List<T>
   Private Class Node
      field succ:Node
      field pred:Node
      field data:T
   End
   field head:Node
end

var x := new List<Int>.Node ' ERROR, Node is Private to List

Class List<T>
   Public Class Node
      field succ:Node
      field pred:Node
      field data:T
   End
   field head:Node
end

var x := new List<Int>.Node ' perfectly OK, Node is Public

Function Main:Int()

    Local main:Window = New Window(800, 600)

    main.Position(100, 100)  ' works

    main.Position = 100, 100 ' doesn't work in MonkeyX
                             ' should automatically translate
                             ' to Position(100, 100) or setPosition(100, 100)

    main.Show()

    Return 0
End

Class Window
    Method New()
        ' create Window using default values
    End

    Method New(width:Int, height:Int, flags:Int = 0)
        ' create Window using default/random x,y
    End

    Method New(x:Int, y:Int, width:Int, height:Int, flags:Int = 0)
        ' create Window
    End
    
    Method Show(status:Bool = True)
    End
    
    Method Hide(status:Bool = True)
    End

    Method Position:Void(x:Int, y:Int) Property
        ' set Window position
    End
End

package main

import "fmt"

func main() {
    x, y := Position()

    fmt.Println(x)
    fmt.Println(y)
}

func Position() (int, int) {
    return 800, 600
}

x, y = main.Position

f, err := os.Open(name)
if err != nil {
    return err
}
codeUsing(f)

Local a:Object = Null
Local b:Object = Null
Local c:Object = New Object
Local d:Object = a ?? b ?? c
' a and b are null, therefore d = c

Class MyClass
  Private
    Field _count:Int
  Public
    Property Count:Int()
	Get  
	    Return _count
	End Get
	Set(value:Int)   'Optional block, if omitted, property becomes read-only
	    _count = value
	End Set
    End Property
End Class

Class MyClass
  Private
    Field _count:Int
  Public
    Property Count:Int()
	Getter  
            Return _count
	Setter (value:Int) 
	    _count = value
    End Property
End Class

Macro HiWord(_value_)
    Word( (( DWord(_value_) >> 16) & $FFFF) )
End Macro

Macro LoWord(_value_)
    Word( ( DWord(_value_) & $FFFF) )
End Macro

Import "User32.lib"
    Function MessageBox:Int32(hWnd:UInt, text:StringPtr, caption:StringPtr, type:UInt32)
    Function MsgBox:Int32(hWnd:UInt, text:StringPtr, caption:StringPtr, type:UInt32) As "_MessageBoxW@16"
End Import

Import "sourcefile.cpp"
    Class xyz
        Method New( x:String )
    End
End Import

Enum MONITOR_DPI_TYPE
    MDT_Effective_DPI  = 0
    MDT_Angular_DPI    = 1
    MDT_Raw_DPI        = 2
    MDT_Default        = MDT_Effective_DPI
End Enum

Class MyClass
  Private
    Field _count:Int
  Public
    Property Count:Int()
	Getter  
            Return _count
	Setter (value:Int) 
	    _count = value
    End Property
End Class

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

local t:int
local p:int ptr=varptr t
p[0]=100
print t

private

global p:intr ptr

function dangerous:void( t:int )
   p[0]=t
end

public

function safer:void( t:int )
   unsafe  'pause GC/whatever
      dangerous( t )
   end      'resume GC/whatever
end

Import "User32.lib"
    Function MessageBox:Int32(hWnd:UInt, text:StringPtr, caption:StringPtr, type:UInt32)
    Function MsgBox:Int32(hWnd:UInt, text:StringPtr, caption:StringPtr, type:UInt32) As "_MessageBoxW@16"
End Import

Function MyWndProc:int( wparam:int, etc...) Extern "stdcall"   'can only be used with static functions.
    'dodgy code goes here...
End

Import "qtmonkey.lib" Extern "stdcall"
   ...decls...
End

Import "qtmonkey.lib"
Extern "stdcall"
   ...decls...
End

Class Foo
	Property Bar:String
		Get
		Set
	End
End

Local a := New Foo
Local prop := Foo.Bar
prop[a] = "hello"
Print prop[a]
Print a.Bar ' same output as the previous line

Extern "C++" {
	cout << "hello";
} End

Class Entity Abstract
	Method Shoot() Abstract
End
Class Enemy Extends Entity
	Method Shoot()
		Print "Enemy shoots"
	End
End
Class Tower Extends Entity
	Method Shoot()
		Print "Tower shoots"
	End
End

Function ShootAll(list:List<? Extends Entity>)
	For Local e := EachIn list
		e.Shoot() ' possible because we know that regardless of the wildcard, it at least extends Entity
	Next
End

Local enemies:List<Enemy> = New List<>() ' "diamond operator" type inference when instantiating generics
Local towers:List<Tower> = New List<>()

ShootAll(enemies) ' possible because Enemy extends Entity
ShootAll(towers) ' possible because Tower extends Entity

Function ShootAll<T>( list:List<T> )
   For Local e:=EachIn list
      e.Shoot()
   Next
End

Class<T> C Where T Extends Entity
End

Function ShootAll<T>:Void( list:List<T> ) Where T Extends Entity     'T must extend Entity!
   ...
End

Function ShootAll<T>:Void( list:List<T> ) Where Entity Extends T     'T must be base class of entity!

Function ShootAll<T Extends Entity>(list:List<T>)

// Swift: string interpolation
var x = 12
// The value of x is 12 
println( "The value of x is \(x)." )

' Monkey 2: possible string interpolation
Local x:Int = 12
' The value of x is 12 
Print "The value of x is ~(x)."

' Monkey 2: possible string interpolation with proposed embedded formatting capabilities
Local energyFloat:Float = 120.1000002001

Print "The value of energyFloat is ~(energyFloat,%.02f)."          ' Prints The value of energyFloat is 120.10

Local energyDisplay:String = "Energy Level: ~(energyFloat,%.02f)"       ' The value of energyDisplay String is now "Energy Level: 120.10

' Of course if the format string is optional so the base works when the standard output format is ok
Print "The value of energyFloat is ~(energyFloat)."          ' Prints The value of energyFloat is 120.1000002001

Print String.Format("energyFloat=%.3f", energyFloat)

@interface Image (MyCategory)
-(void)MyDrawX:(float)x
             y:(float)y
             z:(float)z
         angle:(float)angle;
@end

@implementation Image (MyCategory)
-(void)MyDrawX:(float)x
             y:(float)y
             z:(float)z
         angle:(float)angle
{
	// PushMatrix
	// Rotate angle
	// DrawImage self, x, y, angle
	// PopMatrix
}
@end

Image *alien;
alien = LoadImage( @"alien.png");
[alien MyDrawX:200 y:300 z:40 angle:45];

Class Image Extension
	Method MyDraw:Void(x:Float, y:Float, z:Float, angle:Float)
		' code using the usual "Self" reference
	End
End

Local img:Image = LoadImage("alien.png")
img.MyDraw(1, 2, 3, 4)

class Image_extension_wrapper {
public:
	static void MyDraw(Image *self, float x, float y, float z, float angle) {
		// code using the argument "self"
	}
};

Image *img = LoadImage("alien.png");
Image_extension_wrapper::MyDraw(img, 1, 2, 3, 4);

Class Image Extension
...

Function Something:Int() ( x:Int )
   Function Bump:Int()
      Return x+1
   End
   Return Bump
End

local x = 3
local r = function()
	print(x) -- x doesn't need to be final
	x = 10 -- x can be assigned
end
r()
print(x) -- x has changed

final int x = 3;
Runnable r = new Runnable() {
	public void run() {
		System.out.println(x); // requires x to be final or it won't compile
		x = 10; // won't compile, because x is final
	}
}
r.run();
System.out.println(x); // x hasn't changed

Interface Bar
End
Class Foo Implements Bar
End
Class Foo Extension Bar
End

obj.func = Function:Void()
               ' DoSomething()
           End

' function call with 2 anonymous functions as arguments
myFunction( Function:Int()
                DoSomething()
            End,
            Function:Int(x:Int, y:Int)
                DoSomething()
            End )

' With ; delimiter
myFunction( Function:Int(); DoSomething(); End,
            Function:Int(x:Int, y:Int); DoSomething(); End )

myFunction( Function:Int(); DoSomething(); End, Function:Int(x:Int, y:Int); DoSomething(); End )

obj.func = Function:Void(); DoSomething(); End

Function f3:Void(); Print("f3"); End

[Expression] := [AnonymousFuncDeclaration] |
                [RealExpression]

Function Something:Int() ( x:Int )
   Function Bump:Int()
      Return x+1
   End
   Return Bump
End

Function Something:Int(s:String) ( x:Int )
   Function Bump:Int(s:String)
      Print(s)
      Return x+1
   End
   Return Bump
End

Function Something:Int(s:String) ( x:Int )
   Return Function:Int(s:String)
             Print(s)
             Return x+1
          End
End

func := Something(2)
x := func("Hello")

x := Something(4)("Hello")
Print(x)

local y = map(fn("L1[P1]", translate), x)

function fn(s, ...)
  local src = [[
    local L1, L2, L3, L4, L5, L6, L7, L8, L9 = ...
    return function(P1,P2,P3,P4,P5,P6,P7,P8,P9) return ]] .. s .. [[ end
  ]]
  return loadstring(src)(...)
end

Function Something:Int(s:String) ( x:Int )

    Function GetFunc:Int(s:String) ( y:Int )

        Function Bump:Int(s:String)
            Print(s)
            Return x*y ' parent/outer function parameters get accessed
                       ' by using an activation record that gets
                       ' carried with the function variable?
        End

        Return Bump
    End

    Return GetFunc(x*x)

End

func := Something(2)
x := func("Hello")
Print(x) ' 8

y := Something(4)("World")
Print(y) ' 64

myFunction( Function:Int()
                DoSomething()
            End,
            Function:Int(x:Int, y:Int)
                DoSomething()
            End )

function myFunction(x:int, y:int, f1:function, f2:function, makeLove:bool = false)
end

result = myFunction(10, 20, f1, f2, true) where ' <- postpone parameters declaration and starts a block (should be easier to parse?)
    f1 = function(foo:int, bar:int)
        ' function body
    end[function]
    f2 = function(param1:string, param2:string)
         ' function body
    end[function]
end[where]

function myFuction(x:int, y:int, name:string) where x > 0, x < 100, name.Length() > 4
    ' Monkey automatically generates for us at compile time as the very first code in the function:
    if not (x > 0 and x < 100 and name.Length() > 4) then return ' or throw, or whatever
end

'
' event handler
'
obj.func = func1 where
    func1 = function:int(x:int, y:int, name:string) where x > 0, x < 100, name.Length() > 4
                ' function body
            end
end

'
' function call
'
result = myFunction(a, b, c, d, true) where
    c = function(foo:int, bar:int) where foo > 0 And foo < 11, bar <= 100
        ' function body
    end
    d = function(param1:string, param2:string) where param1 <> "", param2 <> ""
         ' function body
    end
end

function f:int(x:int, y:int, name:string) where x > 0, x < 100, name.Length() > 4
    ' function body
end

function f:int(x:int, y:int, name:string) where x > 0,
    x < 100,
    name.Length() > 4
    ' function body
end

function f1:int(x:int, y:int, name:string)
    Ensure x > 0; x < 100; name.Length() > 4
    ' function body
end

function f2:int(x:int, y:int, name:string)
    Ensure x > 0 And x < 100
    Ensure name.Length() > 4
    ' function body
end

x = function(a:int, b:int, c:function) ' anonymous function. Note that "c" is of function type, can't take something else
    return c(a, b) ' calls the callback passing the first two arguments, and returns the result 
end

' later on...
sum = x(2, 3, f) where
    f = function(a:int, b:int)
        return a + b
    end
end

product = x(10, 20, f) where
    f = function(a:int, b:int)
        return a * b
    end
end

function f2:int(x:int, y:int, name:string)
    Ensure x > 0 And x < 100
    Ensure name.Length() > 4
    ' function body
end

function StartAt:int{int}( x:int )    'int{int} syntax will go!

	function IncrementBy:int( y:int )
		return x+y
	end
	
	return IncrementBy
end

function test:void( f:int{int} )
	print f( 3 )
end	

function main:void()

	local f1:=StartAt( 1 )
	local f2:=StartAt( 5 )
	
	test( f1 )
	test( f2 )
	
end

function main_func:int( main_param:int )

    Local x := 4
    Local i := 5

    function a1:int( a1_param:int )

        Local x := 1

        function a2_1:int( a2_1_param:int )
            return a2_1_param - main_param
        end

        function a2_2:int( a2_2_param:int )
            Local x := 10
            return a2_2_param - b1(15) + x + a2_1(12)
        end

        return a2_1(a1_param + i) * a2_2(x*x)

    end

    function b1:int( b1_param:int )

        Local x := 2

        function b2_1:int( b2_1_param:int )
            return 15 * c1(b2_1_param)
        end

        function b2_2:int( b2_2_param:int )
            return 30 * c1(b2_2_param)
        end

        return i + x + b2_1(8) + b2_2(16) + c1(32)

    end

    function c1:int( c1_param:int )

        Local x := 3

        function c2_1:int( c2_1_param:int )
            return i + x + main_param + c2_1_param
        end

        function c2_2:int( c2_2_param:int )
            return i + x + main_param + c2_2_param
        end

        return c2_1(c1_param + x) - c2_2(c1_param + i)

    end

    return a1(15 + main_param)
end

value := main_func(42)
Print( value )

...
Local a1:=function(...)   'captures all *existing* locals, so can't capture b1, c1
...
Local b1:=function(...)   'can capture a1, but not c1.
...
Local c1:=function(...)   'can capture a1, b1
...

function f2:int(x:int, y:int, name:string)             ' Monkey1
    #if DEBUG
        if x > 0 And x < 100 and name.Length() > 4
            throw Exception
        end
    #endif
    ' function body
end

function f2:int(x:int, y:int, name:string)             ' using Macros (or Monkey1 functions)
    Require( x > 0 And x < 100 )
    Require( name.Length() > 4 )
    ' function body
end

Function Require:Void(x:Bool)
    #if DEBUG
        ' check x and throw or output message
    #endif
End

f x y  |  y>z           =  ... execute only if y > z
       |  y==z          =  ... execute only if y equals z
       |  y<z           =  ... execute only if y < z
     where z = x*x

function myComplexAlgorithm:int(x:int, y:int, z:int)
    #if ARGUMENTS_VALIDATION
        if x < 0 then throw
        if y > 10 ...
        ...
    #end
end

diceRoll = { (1,1): "snake eyes", (6,6): "box cars" }
myBoat = { "NAME":"KaDiMa", "LOA":18, 
 "SAILS":["main","jib","spinnaker"] }

def generic_return(code)
  one, two    = 1, 2
  three, four = code.call(one, two)
  return "Give me a #{three} and a #{four}"
end

puts generic_return(lambda { |x, y| return x + 2, y + 2 })

Local x = Lambda (a:int, b:int, c:Func) Returning c(a, b) 

Local x = Lambda (a:int, b:int, c:Func) Returning c(a, b)

Alias CalcFunc:int(a:int, b:int)
Function calc:int(a:int, b:int, c:CalcFunc) Inline; return c(a, b); End


' later on...
Local sum := calc(2, 3, Function:int(a:int, b:int)
                          return a + b
                        End )

Local product := calc(10, 20, Function:int(a:int, b:int)
                                return a * b
                              End )

' one-liner, if functions are small
Local   sum   := calc( 2,  3, Function:int(a:int, b:int); return a + b; End )
Local product := calc(10, 20, Function:int(a:int, b:int); return a * b; End )

Alias CalcFunc:int(a:int, b:int)
Function calc:int(a:int, b:int, c:CalcFunc) Inline; return c(a, b); End

' one-liner, if functions are small
Local   sum   := calc( 2,  3, lambda<CalcFunc>( return a + b ) )
Local product := calc(10, 20, lambda<CalcFunc>( return a * b ) )

' or
Local   sum   := calc( 2,  3, lambda:CalcFunc< return a + b > )
Local product := calc(10, 20, lambda:CalcFunc< return a * b > )

' or
Local   sum   := calc( 2,  3, lambda:CalcFunc return a + b )
Local product := calc(10, 20, lambda:CalcFunc return a * b )

' or
Local   sum   := calc( 2,  3, CalcFunc< return a + b > )
Local product := calc(10, 20, CalcFunc< return a * b > )

' or
Local   sum   := calc( 2,  3, CalcFunc( return a + b ) )
Local product := calc(10, 20, CalcFunc( return a * b ) )

' or
Local   sum   := calc( 2,  3, lambda:CalcFunc( return a + b ) )
Local product := calc(10, 20, lambda:CalcFunc( return a * b ) )

' or
Local   sum   := calc( 2,  3, lambda:int(a:int, b:int)( return a + b ) )
Local product := calc(10, 20, lambda:int(a:int, b:int)( return a * b ) )

class Collections<T>
    function Filter:ICollection<T>(collection:ICollection<T>, f:bool{T}, stopOnFalse:bool = false)
        local filteredCollection:= new Collection<T>
        for local e:= eachin collection
            if f(e)
                filteredCollection.Add(e)
            else
                if stopOnFalse then exit
            end
        next
        return filteredCollection
    end
end

' class MyList implements ICollection
local list:MyList<SomeItem> = getItemListSomewhere()

' parameters inside delimiters, function body after keyword
list = Collections<SomeItem>.Filter(list, lambda:bool (i:SomeItem) returning i.GetPrice() > 100, false)
list = Collections<SomeItem>.Filter(list, lambda:bool {i:SomeItem} returning i.GetPrice() > 100, false)
list = Collections<SomeItem>.Filter(list, lambda:bool |i:SomeItem| returning i.GetPrice() > 100, true)

' parameters separated from lambda keyword by whitespace and from function body by symbol, 
list = Collections<SomeItem>.Filter(list, lambda:bool i:SomeItem -> return i.GetPrice() > 100)
list = Collections<SomeItem>.Filter(list, lambda:bool i:SomeItem = return i.GetPrice() > 100)

' tidier (usually "=>" implies "returning the following"; see C#, Dart, ...)
list = Collections<SomeItem>.Filter(list, fn:bool {i:SomeItem} => {i.GetPrice() > 100})
list = Collections<SomeItem>.Filter(list, fn:bool {i:SomeItem} => i.GetPrice() > 100)
list = Collections<SomeItem>.Filter(list, fn:bool {i:SomeItem} { return i.GetPrice() > 100 })

' parameter types inferred from Collection.Filter signature? Seems logic since their types couldn't possibly differ anyway
' We are passing a parameter to a function, which has to be type-checked against its signature
list = Collections<SomeItem>.Filter(list, fn {i} => i.GetPrice() > 100, true)

Local f:=Function<CalcFunc>( a:Int, b:Int ); Return a+b; End	' if ; are required if on same line
'or
Local f:=Function<CalcFunc>( a:Int, b:Int ) Return a+b End	' monkey style
'or
Local f:=Function<CalcFunc>( a:Int, b:Int )			
	Return a+b
End

a = 1 b = 2 c = 3

Local mul := Function(x,y) x * y               ' Type inference: compiler decides return type from Input types
                                               ' Input could be floats, integer, bytes, matrices


Local mul := Function:int(x:int, y:int) x * y  ' this would explicitely allow int only

Local x := mul(5,11)                           ' if used with  int , typeOf(x) will be int
                                               ' if used with float, typeof(x) will be float
Print(x)

Function(x,y) x * y

Function(x,y) return x * y
' or
Function(x,y) return [expression]

Function(x,y)
    return [expression]
End

Local f1 := Function:type(args)<end-of-line>  ' EOL means it's a full function with body
                ' function body
            End

Local f2 := Function:type(args) return [expression]
' or
Local f2 := Function:type(args) [expression]  ' omiting 'return'

Local f:=Function<CalcFunc>( a:Int, b:Int ); Return a+b; End    ' if ; are required if on same line
'or
Local f:=Function<CalcFunc>( a:Int, b:Int ) Return a+b End  ' monkey style
'or
Local f:=Function<CalcFunc>( a:Int, b:Int )         
    Return a+b
End

Function f:function<CalcFunc>( a:Int, b:Int )
    Return a+b
End

ProcessList(list, Function(person As Person) person.age > 50)

interface GUIElements
    method Each:GUIElements(f:void{GUIElement}) ' processes each element in the collection, returns self for chaining
    method Filter:GUIElements(f:bool{GUIElement}) ' filter out unwanted elements from the collection, returns self
end

' get a collection consisting of all buttons in the GUI and disable them
local disabledButtons:= GUI.GetElements("button").Each(f) where   ' given? whatever...
    f = function(e)     ' <- types inferred
        e.Disable()
    end
end

local disabledButtons:= GUI.GetElements("button").Each(f) where
    f = function(e) => e.Disable()
end

local disabledButtons:= GUI.GetElements("button").Filter(onlyVisible).Each(disable).Each(animate) where
    onlyVisible = function(e) => e.IsVisible()
    disable = function(e) => e.Disable()
    animate = function(e) => e.Animate("x", GetScreenWidth() + e.GetWidth(), 500) ' every button goes offscreen in 500 ms

    ' alternate syntax for word lovers
    ' disable is function(e) returning e.Disable()
end

local disabledButtons:= GUI.GetElements("button").Each(function(e) => e.Disable())

obj.func = Function(x) [statement-list]
obj.func = Function(x) [statement]
obj.func = Function(x)
             [statements]
           End

person.age > 50

ProcessList(list, Function:bool(person:Person) return person.age > 50)

ProcessList(list, Function:bool(person:Person) Debug(person.ToString()); return person.age > 50)

ProcessList(list, Function:bool(person:Person)
                      Debug(person.ToString())
                      return person.age > 50
                  End )

Function processPerson:bool(person:Person)
    Debug(person.ToString())
    return person.age > 50
End

ProcessList(list, processPerson)

ProcessList(list, Function(person As Person) person.age > 50)

Function A:Int(x:Int, y:Int = 3)
	Return x+y
End

Function B:Int(x:Int, y:Int, f:Function<Int(Int,Int)>)
	Return f(x, y)
End

Function C:Int(x:Int, f:Function<Int(Int)>)
	Return f(x)
End

Function Main:Void()
	Print("B(1,2,a) = " + B(1,2,A))
	Print("C(1,a) = " + C(1,A))
End

' Interface for functions of type Void with 0 parameters
Interface Function_0_Void
	Method Invoke:Void()
End

' Interface for functions with return type and 1 parameter
Interface Function_1_Ret<ReturnType, ParamType1>
	Method Invoke:ReturnType(ParamType1)
End

' Interface for functions with return type and 2 parameters
Interface Function_2_Ret<ReturnType, ParamType1, ParamType2>
	Method Invoke:ReturnType(ParamType1, ParamType2)
End

' Interface for functions with return type and 3 parameters
Interface Function_3_Ret<ReturnType, ParamType1, ParamType2, ParamType3>
	Method Invoke:ReturnType(ParamType1, ParamType2, ParamType3)
End

' Class for function A
Class Function_A Implements Function_1_Ret<Int,Int,Int>, Function_2_Ret<Int,Int,Int>
	Method Invoke:Int(x:Int, y:Int = 3)
		Return x+y
	End
End

' Function A
Global A := New Function_A

' Class for function B
Class Function_B Implements Function_3_Ret<Int,Int,Int,Function_2_Ret<Int(Int,Int)>>
	Method Invoke:Int(x:Int, y:Int, f:Function_2_Ret<Int(Int,Int)>)
		Return f(x, y)
	End
End

' Function B
Global B := New Function_B

' Class for function C
Class Function_C Implements Function_2_Ret<Int,Int,Function_1_Ret<Int(Int)>>
	Method Invoke:Int(x:Int, f:Function_1_Ret<Int(Int)>)
		Return f(x)
	End
End

' Function C
Global C := New Function_C

' Class for function Main
Class Function_Main Implements Function_0_Void
	Method Invoke:Void()
		Print("B(1,2,a) = " + B(1,2,A))
		Print("C(1,a) = " + C(1,A))
	End
End

Function CreateAdder:Function<Int(Int)>(x:Int)
	Function F:Int(y:Int)[x]
		Return x+y
	End
	Return F
End

' Interface for functions with return type and 1 parameter
Interface Function_1_Ret<ReturnType, ParamType1>
	Method Invoke:ReturnType(ParamType1)
End

' Class for function CreateAdder
Class Function_CreateAdder Implements Function_1_Ret<Function_1_Ret<Int,Int>,Int>
	Method Invoke:Function_1_Ret<Int,Int>(x:Int)
		Local F := New Function_CreateAdder_F(x)
		Return F
	End
End

' Class for function CreateAdder.F
Class Function_CreateAdder_F Implements Function_1_Ret<Int,Int>
	Field x:Int
	
	Method New(x:Int)
		Self.x = x
	End
	
	Method Invoke:Int(y:Int)
		Return x+y
	End
End

' Function CreateAdder
Global CreateAdder := New Function_CreateAdder

Function CreateAdder:Lambda<Int(Int)>(x:Int)
	Local F := Lambda:Int(y:Int)[x]
		Return x+y
	End
End

Local isPossitive := Function(value1:Int) value1>=0

Local isPositive:Bool(param1:Int) = Function(value1:Int) Returns value1 >= 0

'Return statement could be optionally omitted?  I still think omitting the separator looks ugly and will make nested Lambdas look like crap...
'Think of it as a syntax sweetener
Local sum = Lambda( a:Int, b:Int) Returning a+b   

Local fact = Lambda:Int( n:Int) 
  If n <= 1 Then Return 1 Else Return (n * fact(n-1))
End Lambda

Function MyFunction:Bool(param1:Int, param2:Float, param3:String)
    
    For Local x:= 1 To 10
        ...
    Next

    If param1
        ...
    ElseIf param2
        ...
    Else
        ...
    EndIf

EndFunction

function MyFunction:bool(param1:int, param2:float, param3:string)
    
    for local x:= 1 to 10
        ...
    next
    
    if param1
        ...
    else if param2
        ...
    else
        ...
    end

    if param1 then ...     ' <- OMG missing End keyword!!

end

class Dog  
  def initialize(breed, name)  
    # Instance variables  
    @breed = breed  
    @name = name  
  end  
  
  def bark  
    puts 'Ruff! Ruff!'  
  end  
  
  def display  
    puts "I am of #{@breed} breed and my name is #{@name}"  
  end  
end

Hash["a" => 100, "b" => 200]         #=> {"a"=>100, "b"=>200}

["one", "two", "three"].map {|n| puts n.upcase }

class Doctor
  ["rhinoplasty", "checkup", "interpretive_dance"].each do |action|
    define_method("perform_#{action}") do |argument|
      "performing #{action.gsub('_', ' ')} on #{argument}"
    end
  end
end

Why The Uppercase Madness? Does It Make Everything More Readable? THE ORIGINAL BASIC WAS WRITTEN LIKE THIS... GOOD TIMES :)

123 Exp 5 = 123 * 10^5

,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>

class myClass extends baseClass implements IDisposable

class myClass : baseClass, IDisposable

class myClass

    public methods:

    goThere:void()
        ...
    end

    doThat:int()
        ...
    end


    private methods:

    countToTen:void()
        ...
    end


    private fields:

    a:int = 1
    b:myClass = null
    c:float

end

class myClass extends baseClass implements IDisposable

class myClass : baseClass, IDisposable

class Foo: Bar

class myClass extends baseClass implements IDisposable

class MyClass From baseClass,IDisposable

Function Rnd#()
	Seed=(Seed*A+C)|0
	Return Float(Seed Shr 8 & $ffffff)/$1000000
End
'where A and C are constants

Function Move:{Int, Int}(x:Int, y:Int, amount:int)
	x += amount
	y += amount
	Return x, y
End

Local {newX:Int, newY:Int} = Move(5, 5, 1)

If Move(2, 2, 1){1} = 3
	
EndIf

    func minMax(array: [Int]) -> (min: Int, max: Int) {
        var currentMin = array[0]
        var currentMax = array[0]
        for value in array[1..<array.count] {
            if value < currentMin {
                currentMin = value
            } else if value > currentMax {
                currentMax = value
            }
        }
        return (currentMin, currentMax)
    }

public static void main

// C++
struct Point {
    int x, y;
};

Point foo(int i){
    Point pt;
    pt.x = 10;
    pt.y = 10;
    return pt;
}        

int main () {
    Point p;
    p = foo(5);
    return 0;
}

Point p;
foo(&p, 5); // p = foo(5);

function myFunction()
    return [
        1, 2,
        3, 4]
end

local myArray:= myFunction()
Print myArray[2]
' or even Print myFunction()[1]

function myFunction(x)
    return [
        a => x,
        b => x * x,
        c => x * x * x]
end

local myStruct:= myFunction(5)
Print myStruct.c

return {
    a: x,
    b: x * x,
    c: x * x * x}

' predeclare the damn thing, okay...
struct myStruct
    field x:float
    field y:float
    field name:string
end

function myFunction:myStruct(x:float)
    return [
        x => x / 3,
        y => x / 5,
        name => "foo"]
end

function name:string(s:myStruct)
    return s.name
end

Class Foo
  Private
    Field _myVar

  Protected
     'Protected vars here 

  Public
    'Globals here
    'Public fields here

 'Properties
  Method MyVarReadOnly() Property
    Return _myVar
  End Method

  'Non-property methods here

  'Functions here
End Class

function update()   'lowercase so private
end

function Update()   'uppercase so public
end

Strict

Class Foo
    Private Field _myVar:Int

    Public Field x:Int

    Public Method MyVar:Int() Property
        Return _myVar
    End

    Protected Field prot:Int

    Private Method MyVar:Void(x:Int) Property
        _myVar = x
    End
End

Class Bar
    Private

        Field _myVar:Int

    Public

        Field x:Int

        Method MyVar:Int() Property
            Return _myVar
        End

    Protected
        
        Field prot:Int

    Private

        Method MyVar:Void(x:Int) Property
            _myVar = x
        End
End

Function Main:Int()
    Local obj1:= New Foo
    Print obj1._myVar
    Print obj1.x
    Print obj1.prot
    obj1.MyVar = 10
    Print obj1.MyVar
    
    Local obj2:= New Bar
    Print obj2._myVar
    Print obj2.x
    Print obj1.prot
    obj2.MyVar = 10
    Print obj2.MyVar
    
    Return 0
End

Public Field x:Int
Method Foo:Void(); End

Private Field y:Int
Method Bar:Void(); End

Public
Field x:Int
Method Foo:Void(); End

Private
Field y:Int
Method Bar:Void(); End

Public Field x:Int
Public Method Foo:Void(); End

Private Field y:Int
Private Method Bar:Void(); End

Class PerspectiveCamera Extends Camera = "THREE.PerspectiveCamera"
    Function Create:PerspectiveCamera(args) = "CreatePerspectiveCamera" ' becomes automatically 'THREE.PerspectiveCamera.CreatePerspectiveCamera'
End

Class MySingleton
'Prefix
  Private Global shared_var:Int
  Public Method DoNothing:Void() Final Property

'Postfix
  Global shared_var:Int Private
  Method DoNothing:Void() Public Final Property
End Class

Class MySingleton
  Private Global shared_var:Int
  Public Final Property Method DoNothing:Void()
'or
  Public Final Property DoNothing:Void()
End Class

function UpDaTe() ' protected

Field matrix:Float[]   'private...
Field scissor:Float[]
 
Method Draw:Void()  'public
   PushMatrix
   PushScissor
   OnDraw
   PopScissor
   PopMatrix
End

Method onDraw:Void()    'private-ish. To make really private, use 'Final'...
   ...
End

Method Draw:Void()
   PushMatrix
   PushScissor
   Derived.Draw
   PopScissor
   PopMatrix
End

class MyClass
    field aField:int readonly
end

Class MyStack<T> Extends Stack<T>
   Method Sort:Void()
     ArraySort<T>.Sort Data,0,Length
   End
End

private

Public Field foo
Private Field bar
Protected Method Hello()
End

Public
Field foo

Private
Field bar

Protected
Method Hello()
End

shaderCode = "line 1" +
             "line 2" +
             "line 3"

shaderCode = "line 1" +
             "line 2" +
             "line 3"

' Many other languages

Select GetChar()
    Case 'a', 'A'
    Case 'z', 'Z'
    Case '+', '-', '*', '/'
EndSelect

' Monkey X

Select GetChar()
    Case "a"[0], "A"[0]
    Case "z"[0], "Z"[0]
    Case "+"[0], "-"[0], "*"[0], "/"[0]
EndSelect

' VB style, http://stackoverflow.com/questions/3374842/how-do-you-declare-a-char-literal-in-visual-basic-net

Select GetChar()
    Case "a"c, "A"c
    Case CChar("z"), CChar("Z")
    Case "+"c, "-"c, "*"c, "/"c
EndSelect

Select GetChar()
    Case 1 To 31
    Case "a"[0] To "z"[0]
    Case "0"[0] To "9"[0]
EndSelect

#!/bin/monkey2
# monkey script

Function SomeFunction:Void()
    Select GetChar()
        Case 1 To 31
        Case 'a' To 'z'
        Case '0' To '9'
    End
End

Select chara
  Case 0  'Standard
  Case 1, 2  'Each arg is a separate case eval against chara
  Case 3 To 5 Step 1  'Similar to For syntax;  Step optional
  Case Is > 100   '"Is" is a stand-in for the variable being switch evaluated. This means...
  Case Is > 5 And Is < 100  '..that it can be used anywhere chara would be in a non-Select expression
  Default
End Select

Case "+"[0], "-"[0], "*"[0], "/"[0]

<SHIFT+C> <a> <s> <e> <Space>
<SHIFT+2> <+> <SHIFT+2> <ALT-GR+8> <0> <ALT-GR+9> <,> <Space>
<SHIFT+2> <-> <SHIFT+2> <ALT-GR+8> <0> <ALT-GR+9> <,> <Space>
<SHIFT+2> <SHIFT++> <SHIFT+2> <ALT-GR+8> <0> <ALT-GR+9> <,> <Space>
<SHIFT+2> <SHIFT+7> <SHIFT+2> <ALT-GR+8> <0> <ALT-GR+9>

Local ascA:Int = %A  'Maybe?

Local hex := $A
Print hex
Local bin := %10001101
Print bin

^a^    ^a        ^ comment - usually read as 'power of'
°a°    °a        ° comment
#a#    #a        # comment
\a\    \a        \ comment
?a?    ?a        ? comment - question?
!a!    !a        ! comment!
§a§    §a        § comment
µaµ    µa        µ comment

                 ## comment
                 '' comment
                 // comment
                 /* comment */

Local a:Int = 5
Local b:Int = a
Select True
	Case a>100 Print "a greater 100"
	Case a>5 And a<100 Print "a between"
	Case a=5 And b=a Print "a b = 5"
End

Select expression
    Case statements...
End Select

Select [expression]
    Case [expression]
End Select

Select True
    Case [expression] ' can be any expression, like 'a > 100 And b=12'
End Select

Class Layer
	
	Method Update:Void()
		If enabled
			For obj = Eachin rootList
				obj.Update()

	Method AddEntity:Void( ent:Entity )
		If ent.layer <> Null
			If ent.layer <> Self
				ent.layer.rootList.RemoveEach( ent )
				ent.layer.entities.RemoveEach( ent )
		rootList.AddLast( ent )
		entities.AddLast( ent )
		Game.entities.Add( name, ent )
	
	Method Draw:Void()
		If visible
			For obj = Eachin rootList
				obj.Draw()
	
	Method Reset:Void()
		For obj = Eachin rootList
			obj.Reset()

From os Import LoadString, SaveString