class Test
{
	Test {
		data = {1.3,5,6};
	}

	Test(int a) {
		data = {a};
	}
	/* This is test
		of a multiline
	 data = {12,3};
		comment
	*/

	set(array[int] val) {
		data = val;
	}

	append(int val) { // Return value can be omitted when "void"
		data << val;
	}

	int size {
		return data.size();
	}

	joo {
		data = 1;
		val = size();
		val2 = size;
	}

	int get(int i) { // Return value must be stated when returning something
		return data[i];
	}

	dump {
		print " ";
		print val+" ";
		foreach (val = data) {
			print " ";
			print val+" ";
		}
	}

	mul(int i) {
		data *= i; // Multiple all values of data with i
	}

	mul(int i, int j) {
		data[i] *= j; // Multiple value of data[i] with j
	}

	add(int i) {
		data += i; // Add i to all values of i 
	}

	ref(array[int] &r) {
		r = data;
	}

private:
	array[int] data;
}


class Other : Test
{
	dumpvalue(int i) {
		print "Got "+i+" ";
	}

	test() {
		print data[0]; // This is valid. There's no "real" private, visibility also to inherited classes
	}
}


main()
{
	Test.dump();
	Test tester; // Same as: Test tester = Test();
	Test tester2 = Test(10);

	tester.append(12);

	tester.dump();

	array[int] vals;
	tester.ref(vals); // vals will contain same data as tester.data

	tester2.append->tester2.dump;	// Connect signal
	tester2.append(12);		// First does append, then sends signal
					// tester2.dump() is called because singal is connected


	Other o;
	tester.append->o.dumpvalue;  	// Connect signal
	tester.append(5);		// Calls o.dumpvalue(5); because parameters are passed if their types match.

	//DEPRECATED: [tester.append(5)];		// Parallel call: [object.method(params)];
	@tester.append(5);		// Parallel call: [object.method(params)];

	//int totalsize = [tester.size()]; // Valid, using late binding.
	int totalsize = @tester.size(); // Valid, using late binding.
		// App can do anything here if it wants to
	print totalsize+"\n";		// Valid, will however cause wait until latest assigment is done (thread is done)


	uint32 v = 123213;
	int32 v2 = cast<int32>(variable);
}