User Function

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

// 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.

// With no link
$a = "Test";
$ret = Test($a);
say $a; // Prints Test
say $ret; // Prints Pest
 
// With link
$a = "Cat";
$a->Test();
say $a; // Prints Pat
 
[ShowLink("true")] // Allow creation of @IsLink
Function Test( &$a ) // Ref the $a so we can deal
{                    // with the real one directly
	// True if the user used $a->Test()
	if(@IsLink['a'])
	{
		// Edit the original
		$a[0] = 'P';
	}
	// Else this is a normal Test($a) call
	else
	{
		// Return a modified string
		return 'P' . SubStr($a, 1);
	}
}
// This rule is needed to find out if the user is calling
// the function by:
// Test($a)
// OR
// $a->Test()
// You might wonder why that matters well $a->Test() is
// better to modify the variable in place and
// Test($a) is better used to return a modified copy instead

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'");
};