languageSpecification.ebnf

using MyNamespace

namespace MyNamespaceName
{
	infix func MyInfixFunction(MyTypeA myParamA, MyTypeA myParamB) -> MyReturnType
	{
		...
		return myResult 
	}

	protocol MyProtocolName
	{
        func MyFunc(MyTypeA myParameterName)
        func MyFunc2(MyType myParameterName, ..MyType myParamsParameters) -> MyReturnType        

	}

	func GenericFunction!(TypeA, TypeB)(TypeA a, TypeB b) 
	{
		...
	}
	
	func GenericFunctionSingleArg!(TypeA)(TypeA a) -> int
	{
		let anonFunc : func!(TypeX, TypeY)(TypeX x, TypeY y) -> return x
		anonFunc!(a, a)
	}
	
	class GenericClass(TypeA, TypeB)
	{
		var mutable1 : None TypeA
		var mutable2 : None TypeB
		
		Constructor(TypeA arg1, TypeB arg2)
		{
			mutable1 : arg1
			mutable2 : arg2
			
			var i : GenericFunctionSingleArg!(arg1)
			var b : GenericFunction!(arg1, arg2)
		}
	}
		
	abstract class BaseClass
	{
		func PrivateFoo(){}
		open func OpenFoo(){}
		open func OpenFoo2(){}		
		open func OpenFoo3(){}
		abstract func AbstractFoo(){}
		public abstract func AbstractFoo2(){}
		protected func ProtectedFoo(){}
	}
	
	class MyDerivedClass is BaseClass, MyProtocolName
	{
		func MyFunc(MyTypeA myParameterName){}
		func MyFunc2(MyType myParameterName, ..MyType myParamsParameters) -> MyReturnType
		{
			return new MyReturnType(localA)
		}
	
		override func OpenFoo(){}
		open override func OpenFoo2(){}
		override func OpenFoo3(){}
		override func AbstractFoo(){}
		public override func AbstractFoo2(){ProtectedFoo()}
	}
		
	class MyClassName is MyProtocolName
	{
		let myImmutableReferenceA : new myTypeA()
		let myImmutableReferenceB
		var myMutableReferenceC : None MyTypeA
		
		primary Constructor(MyTypeA constructorParameterA)
		{
			myImmutableReferenceB : constructorParameterA
		}
		
		operator Div(MyClassName opA, MyClassName opB) -> int
		{
			//div operator for MyClassName
		}
		
		func MyFunc(MyTypeA myParameterName)
		{
			myMutableReferenceC : myParameterName MyInfixFunction myParameterName
		}
		
		func MyFunc2(MyType myParameterName, ..MyType myParamsParameters) -> MyReturnType
		{			
			var localA : GetLength(myParamsParameters)
			{
				let immutableLocalScopeB : localA
				if(immutableLocalScopeB is int)
				{
					WorkWithInt(immutableLocalScopeB)
				}
				else throw new Error("Expected int");
			}
			return new MyReturnType(localA)
		}
		
		func GetLength(MyType[] arr) -> return arr.Length(0)
		
		func WorkWithInt(int myInt) -> myInt * 2
		
		func LookAtMyAwesomeMatch()
		{
			match(1)
			{
				case is Int    -> ...
				case !0	       -> ...
				case in 1..10  -> ...
				case !in 11.20 -> ...
				case > 30	   -> ...
				else		   -> 
				{
				
				}
			}
		}
		
		func LookAtMyAwesomeFor(MyType[] arr)
		{
			for(var index, var item in arr)
			{
			}
			
			forr(var index, var item in arr)
			{
			
			}
			
			for(var i : 0; i < arr.Length(0); i+:1)
			{
			
			}
		}
		
		func LookAtMyFunctions(func(int, string, TypeA) functionParameter)
		{
			var funcA : func(int a, int b) -> return a * b
			var val : funcA(1, 2)
			
			var inferredTypedFunc : func(val, val) -> return a * b
		}
		
		func LookAtMyAwesomeIf(int paramA)
		{
			var a : if(paramA > 1) true
					else if(paramA < 3) true
					else if(paramA is int) false
					else false
			
			if(a)
			{
				
			}
			else throw Error("wtf")			
		}
		
		func LookVariableDeclaration()
		{
			var a : 1
			var b : 1, c : new None!(int), d : "string"
			let e : 3, f : "string"
		}
		
		var field : new None!(int)
		func LookOptionalVariables(Optional!(int) integer, Optional!(string) sstring)
		{
			let a : integer
			var c : integer * integer //Error	
			if(a is Some!(int))
			{
				//work with int, inferred from condition
			}
			else throw new ArgumentException("'integer' not initialized")
		}
	}

	class PrimaryConstructorClass
	{
		let immutFieldFromPrimaryConstructor
		primary Constructor(int val)
		{
			immutFieldFromPrimaryConstructor : val
		}
		
		Constructor() : this(1)
		{
			
		}
	}
	
	abstract class Optional!(T)
	{		
	}
	
	class Some!(T) is Optional!(T)
	{
		private var _some
		primary Constructor(T val)
		{
			_some = val
		}
		
		public Get() -> return _some
		public Set(T val)
		{
			_some = val
		}
	}
	
	class None!(T) is Optional!(T)
	{		
	}
	
	class Empty
	
	class NoneInt is None!(int)
	
	class SomeGenericClass!(T1, T2)
		
	class SomeEmptySpecifiedGenericClass!(T) is SomeGenericClass!(Empty, T) where T is MyProtocolName, this, fits Concept
																											 {
																												operator Div(T, T) -> T
																												func Size() -> int
																											 }, Addable!(T)


	
	
	Concept Square!(T) where T : Mult!(T)
	{
		func Square(T val) -> return val * val
	}

	Concept Addable!(T)
	{
		operator Add(T, T) -> T
	}
	
	Concept Mult!(T)
	{
		operator Mult(T, T) -> T
	}
	
	impl Addable!(int) //implies imlp Addable!(T) { operator Add(int a, int b) -> return a.Add(b) }
	impl Mult!(int) //implies imlp Mult!(T) { operator Mult(int a, int b) -> return a.Mult(b) }
	
	func Func!(T)(T val) where T : Addable!(T) + Mult!(T) + DefaultConstructor!(T)
	{
		
	}
	
	Concept Enumerable!(T)
	{
		func Current() -> T
		func Next()
	}
	
	impl Enumerable!(int)
	{
		func Current() -> return this
		func Next()
		{
			this : this + 1
		}
	}
	
	extend int : Enumerable!(int)
	{
		func Current() -> return this
		func Next()
		{
			this : this + 1
		}
	}
	
	Enumerable!(int)
	{
		func Current() -> return this
		func Next()
		{
			this : this + 1
		}
	}
		
	class int : Enumerable!(int)
	{
		func Current() -> return this
		func Next()
		{
			this : this + 1
		}
	}	
		
	impl Square!(int)
	{
	}
	
	Concept DefaultConstructor!(T)
	{
		Constructor()
	}
	
	func Enumerable!(T).Where!(T)(func(T, bool) predicate) -> T
	{
		var result : new List!(T)
		for(T item in this)
		{
			if(predicate(item))
			{
				result.Add(item)
			}
		}
		return result
	}
	
	func CalcAverage()
	{
		var ints : new int[](1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
		var doubles : new dobule[](1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.1, 11.2, 12.3)
		var float : new float[](1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.1, 11.2, 12.3)
		
		int : Addable!(int)
		extend int : Addable!(int)
		
		impl Addable!(int)
		impl Divable!(int)
		impl Addable!(double)
		impl Divable!(double)
		impl Addable!(float)
		impl Divable!(float)
		
		var avInt : ints.Average()
		var avDouble : double.Average()
		var avFloat : float.Average()
	}
	
	func Enumerable!(TNumber).Average() where TNumber : Addable!(TNumber) + Divable!(TNumber) + DefaultConstructor!(T)
	{
		return this.Sum() / this.Count()
	}
	
	func IEnumerable!(T).Sum!(T)() -> T where T fits Addable!(T) + DefaultConstructor!(T)
	{
		T result : new T()
		for(T item in this)
		{
			result += item
		}
		return result
	}
}