User Function

// Make a string
my $MyString = "Hello";
 
// Print it
say $MyString; // Prints "Hello"
 
// Fail to modify it
Test($MyString);
 
// Print to prove fail
say $MyString; // Prints "Hello"
 
// Correctly modify it
Test2($MyString);
 
// Print modified string
say $MyString; // Prints "Hello world!"
 
// A function that does not use a pointer
// so any modifications to the variable
// do not leave the function since it is
// only playing with a *copy*
Function Test($str)
{
	$str .= " world!";
}
 
// A function that does use a pointer so
// any modifications that take place do
// indeed change the variable
Function Test2(&$str)
{
	$str .= " world!";
}

println( Add(1, 2, 3) ); // will return 6
 
Function Add()
{
	my $Total = 0;
	foreach( @args as my $item )
	{
		$Total += $item;
	}
	return $Total;
}

doMsg("Hello", 777);
 
Function doMsg()
{
	my List( $msg, $code ) = @args;
	echo "$msg | $code"; // Prints: Hello | 777
}
// This tends to work very similar to the @_ in perl

// The @Args variable is a special variable
// that exists in all functions it is used to
// handle infinite params the same as perls @_
// parma 0 is @Args[0] and so on...
// of course making this array if its not going
// to be used might slow your program down a
// few minor microseconds so you can remove it
// if you want using this rule.
println("### First no rule");
Test("Cat", "Dog");
println("### Now with rule");
TestWithRule("Cat", "Dog");
 
// A test function with no rules so @args should be created
Function Test($a, $b)
{
	println("\$a: $a \$b: '$b'");
	println("\@args[0]: @args[0] \@args[1]: '@args[1]'");
	printr(@args);
}
 
// This function is same as above but this time with the rule
[Args("false")]
Function TestWithRule($a, $b)
{
	println("\$a: $a \$b: '$b'");
	println("\@args[0]: @args[0] \@args[1]: '@args[1]'");
	printr(@args);
}
// Notice the test with the rule had no @args variable at all?
// This can useful if this function gets called millions of times
// and you want to squeeze every ounce of speed out of it

print(vardump(Test(true)));
print(vardump(Test(false)));
 
[Returns("bool")]
Function Test( $returnBool )
{
	if($returnBool)
		return 1 == 2;
	else
		return "Hello";
}
// This forces this function to require a bool to be returned
// if a bool is not returned it will throw an exception instantly
// it will not try to convert the return to a bool

[ReturnCast("bool")]
Function Test( $returnBool )
{
	if($returnBool)
		return 1 == 2;
	else
		return 1;
}
// This forces this function to return a bool no matter what
// It will even return the default value (0 for ints, false for bool etc)
// if it cannot convert or find a return value at all
// If there is a return value it will converted to a bool

Print("Moo moo farm");
 
[Override("true")]
Function Print()
{
	say "HELLO?!?!??";
}
// This forces all calls to Print() (core) function to go to your
// function instead this can prove useful if you are extending
// the functionality of a core function.
// Be careful however since Sputnik might want to call one of the
// cores and suddenly find it does not exist and behave in weird and/or
// disastrous way.

println( Add(1, 2) ); // will return 3
 
Function Add($a, $b)
{
	return $a + $b;
}

println( Add(2) ); // will return 52
println( Add(2, 4) ); // will return 6
 
Function Add($a, $b = 50)
{
	return $a + $b;
}

println( Add() ); // will return 60
println( Add(2) ); // will return 52
println( Add(2, 4) ); // will return 6
 
Function Add($a = 10, $b = 50)
{
	return $a + $b;
}

Test("CAT", 111);
 
Function Test
{
	my List ($Name, $Password) = @args;
	println("Name '$Name' Password '$Password'");
};