User Function

// Check if the function already exists and
// if it does already exists don't create it
if (!FunctionExists("Cat"))
{
	// Create the function using the Embedded keyword
	Embedded Function Cat()
	{
		say "testy!";
	}; // note ; is required here
}
Cat();
// PRINTS
// testy!

// 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
 
// Allow the @args variable to be made (we will use it)
// you place this above a function to allow @Args
// the reason is becaus the creation of @Args involves
// creating an array and pushing items onto it etc and
// can use a tiny bit of processing power so we don't do
// it unless we want to do it
[Args("true")]
Function Add()
{
	my $Total = 0;
	foreach( @args as my $item )
	{
		$Total += $item;
	}
	return $Total;
}

doMsg("Hello", 777);
 
[Args("true")]
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 can be used in any function it is used to
// handle infinite params the same as perls @_
// param 0 is @Args[0] and so on...
// If you wish to use infinite parameters thenb
// you must enable 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 NOT 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("true")]
Function TestWithRule($a, $b)
{
	println("\$a: $a \$b: '$b'");
	println("\@args[0]: @args[0] \@args[1]: '@args[1]'");
	printr(@args);
}
// Notice the test without the rule had no @args variable at all?

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