========================================================
Primitive Types
========================================================

int8
int16
int32
int64
uint8
uint16
uint32
uint64
float32
float64
bool
achar
wchar
void

========================================================
Decorated Types
========================================================

T[N]						// static array
T*							// pointer to POD type
T^							// handle to struct type
T[]*						// pointer to POD type array
T[]^						// handler to an array
T.U							// offset type

newtype Old New;			// define a new type New from a prototype Old.
							// Old value and New value can be explicit converted to each other.

========================================================
Struct Type
========================================================

struct Point // Point is a new type to Pair<int, Pair<int, void>>
{
	int x;
	int y;
}

struct Point<T>
{
	T x;
	T y;
}

T var;						// T can be any type

T* pvar = alloc T*;
T[]* avar = alloc T[10]*;
T* pvar = &var;
T* pvar = &pvar[0];
free pvar;					// only pointers that created by "alloc" can be "free"-ed

T^ hvar = alloc T^;
T^[]^ avar = alloc T^[10]^;
free hvar;					// only handlers that created by "alloc" can be "free"-ed. Handles are traced by the garbage collector.

========================================================
Value Creating
========================================================

int{10}
Point{x=10, y=10}
alloc Point*{x=10, y=10}
alloc int*{10}
alloc int[10]*{1, 2, 3, 4, 5}
alloc Point^{x=10, y=10}
alloc int[10]^{1, 2, 3, 4, 5}
null

========================================================
Struct Accessing
========================================================

Point p;
p.x=10;
p.y=20;

Point* pvar=&p;
pvar*.x=10;
pvar*.y=20;
pvar*=p;
p=pvar*;

Point^ hvar=alloc Point^;
hvar^.x=10;
hvar^.y=20;
hvar^=p;
p=hvar^;

Point::int px = Point::x;
p.*px=10;
pvar*.*px=10;
hvar^.*px=10;

========================================================
Functions
========================================================

int CompareInt(int a, int b)
{
	return a-b;
}

int CompareDouble(double a, double b)
{
	return a-b;
}

========================================================
Expressions
========================================================

op a
a op
a op b
(T) e;

========================================================
Statements
========================================================

Type var[ = value];
if(condition) statement [else statement]
loop statement
break;
continue;
return [expression];
try statement { catch(ExceptionType^ [var]) statement } [finally statement]
throw handle;

========================================================
Concepts
========================================================

int ComparePoint<T>(Point<T> a, Point<T> b)
	requires Comparable<T>;
{
	int r=Compare(a.x, b.x);
	if(r!=0) return r;
	return Compare(a.y, b.y);
}

int ComparePair<T, U>(Pair<T, U> a, Pair<T, U> b)
	requires Comparable<T>;
	requires Comparable<U>;
{
	int r=Compare(a.first, b.first);
	if(r!=0) return r;
	return Compare(a.second, b.second);
}

concept Comparable<T>
{
	int Compare(T a, T b);
}

instance Comparable<int>
{
	Compare = CompareInt;
}

instance Comparable<double>
{
	Compare = CompareDouble;
}

instance<T> Comparable<Point<T>>
{
	Compare = ComparePoint<T>;
}

instance<T, U> Comparable<Pair<T, U>>
{
	Compare = ComparePair<T, U>;
}

Pair<Point<int>, Point<double>> a, b;
int result=ComparePair<Pair<Point<int>, Point<double>>>(a, b);

========================================================
Storage
========================================================

Type name;				// global variable
Type name<T>;			// global variable template. &name<int> != &name<double>
thread Type name;		// thread local variable