User Function - Revision history

UberFoX: /* Remarks */

2015-09-20T10:08:21Z

Remarks

← Older revision		Revision as of 10:08, 20 September 2015
Line 10:		Line 10:

	=== Features ===		=== Features ===
		+
		+	=== Embedding ===
		+
		+	A class can be embedded inside an IF statement (or any statement) so that it can be created on a conditional for example:
		+
		+	<syntaxhighlight lang="sputnik">
		+	// 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!
		+	</syntaxhighlight>

	=== Remarks ===		=== Remarks ===

UberFoX: /* General Examples */

2015-06-26T02:30:31Z

General Examples

← Older revision		Revision as of 02:30, 26 June 2015
Line 258:		Line 258:


−	In this example we dont include the ( ) on the function and by not including it the function will automatically ~~assume~~ you plan to use the @args variable and will enable it for you	+	In this example we dont include the ( ) on the function and by not including it the function will automatically assumes you plan to use the @args variable and will enable it for you

	<syntaxhighlight lang="sputnik">		<syntaxhighlight lang="sputnik">

UberFoX: /* General Examples */

2015-06-26T02:30:05Z

General Examples

← Older revision		Revision as of 02:30, 26 June 2015
Line 258:		Line 258:


		+	In this example we dont include the ( ) on the function and by not including it the function will automatically assume you plan to use the @args variable and will enable it for you

	<syntaxhighlight lang="sputnik">		<syntaxhighlight lang="sputnik">
	Test("CAT", 111);		Test("CAT", 111);
−
−	~~[Args("true")]~~
	Function Test		Function Test
	{		{

UberFoX: /* General Examples */

2015-06-14T12:53:19Z

General Examples

← Older revision		Revision as of 12:53, 14 June 2015
Line 262:		Line 262:
	Test("CAT", 111);		Test("CAT", 111);

		+	[Args("true")]
	Function Test		Function Test
	{		{

UberFoX: /* Unlimited Function Parameters */

2015-06-14T12:52:24Z

Unlimited Function Parameters

← Older revision		Revision as of 12:52, 14 June 2015
Line 105:		Line 105:
	doMsg("Hello", 777);		doMsg("Hello", 777);

		+	[Args("true")]
	Function doMsg()		Function doMsg()
	{		{

UberFoX at 12:18, 14 August 2014

2014-08-14T12:18:46Z

← Older revision		Revision as of 12:18, 14 August 2014
Line 68:		Line 68:
	If you’ve most likely noticed that several function such as println() can take an indeterminate number of arguments. Normally when defining a function you specify each argument in the function declaration. Obviously it would be impossible to define an infinite number of arguments in such a way. Sputnik does, however, allow you to accomplish this through the array @args.		If you’ve most likely noticed that several function such as println() can take an indeterminate number of arguments. Normally when defining a function you specify each argument in the function declaration. Obviously it would be impossible to define an infinite number of arguments in such a way. Sputnik does, however, allow you to accomplish this through the array @args.

−	@args is an array consisting of all of the arguments passed to a function. Using this method you can bypass the conventional method of defining parameters in the function definition all-together. Here is an example:	+	@args is an array consisting of all of the arguments passed to a function. Using this method you can bypass the conventional method of defining parameters in the function definition all-together.
		+
		+	However @args is not created by default and you must activate it if you wish to use it.
		+
		+	Here is an example:

	<syntaxhighlight lang="sputnik">		<syntaxhighlight lang="sputnik">
	println( Add(1, 2, 3) ); // will return 6		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()		Function Add()
	{		{
Line 109:		Line 120:
	<pre>		<pre>
	TYPE WHAT IT DOES		TYPE WHAT IT DOES
−	Args Allows ~~disabling~~ the creation of @ARGS variable	+	Args Allows enabling the creation of @ARGS variable
	Returns Forces a specific return type to the function		Returns Forces a specific return type to the function
	(gives exception if wrong type is given)		(gives exception if wrong type is given)
Line 115:		Line 126:
	Override Overrides a CORE function with this name and forces all		Override Overrides a CORE function with this name and forces all
	call to that function to route to you function instead		call to that function to route to you function instead
		+	</pre>
		+
		+	Default for the rules
		+	<pre>
		+	TYPE DEFAULT
		+	Args FALSE
		+	Returns <totally disabled>
		+	ReturnCast <totally disabled>
		+	Override FALSE
	</pre>		</pre>

Line 122:		Line 142:
	<syntaxhighlight lang="sputnik">		<syntaxhighlight lang="sputnik">
	// The @Args variable is a special variable		// The @Args variable is a special variable
−	// that ~~exists~~ in ~~all functions~~ it is used to	+	// that can be used in any function it is used to
	// handle infinite params the same as perls @_		// handle infinite params the same as perls @_
−	// ~~parma~~ 0 is @Args[0] and so on...	+	// param 0 is @Args[0] and so on...
−	// ~~of course making this array if its not going~~	+	// If you wish to use infinite parameters thenb
−	// to ~~be used might slow your program down a~~	+	// you must enable this rule.
−	~~// few minor microseconds so you can remove it~~	+
−	// if you ~~want using~~ this rule.	+
	println("### First no rule");		println("### First no rule");
	Test("Cat", "Dog");		Test("Cat", "Dog");
Line 134:		Line 152:
	TestWithRule("Cat", "Dog");		TestWithRule("Cat", "Dog");

−	// A test function with no rules so @args should be created	+	// A test function with no rules so @args should NOT be created
	Function Test($a, $b)		Function Test($a, $b)
	{		{
Line 143:		Line 161:

	// This function is same as above but this time with the rule		// This function is same as above but this time with the rule
−	[Args("~~false~~")]	+	[Args("true")]
	Function TestWithRule($a, $b)		Function TestWithRule($a, $b)
	{		{
Line 150:		Line 168:
	printr(@args);		printr(@args);
	}		}
−	// Notice the test ~~with~~ the rule had no @args variable at all?	+	// Notice the test without 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~~	+
	</syntaxhighlight>		</syntaxhighlight>

UberFoX at 22:41, 13 August 2014

2014-08-13T22:41:26Z

← Older revision		Revision as of 22:41, 13 August 2014
Line 251:		Line 251:
	};		};
	</syntaxhighlight>		</syntaxhighlight>
		+
		+	[[Category:User Defined Functions]]

UberFoX: /* Function Rules */

2014-08-11T19:25:29Z

Function Rules

← Older revision		Revision as of 19:25, 11 August 2014
Line 115:		Line 115:
	Override Overrides a CORE function with this name and forces all		Override Overrides a CORE function with this name and forces all
	call to that function to route to you function instead		call to that function to route to you function instead
−	~~ShowLink Allows creation of @IsLink macro for this function this can~~
−	~~be used to find out if this function is a Test($a) call or a~~
−	~~$a->Test() call~~
	</pre>		</pre>

Line 207:		Line 204:
	// cores and suddenly find it does not exist and behave in weird and/or		// cores and suddenly find it does not exist and behave in weird and/or
	// disastrous way.		// disastrous way.
−	~~</syntaxhighlight>~~
−
−	~~Example of using Rule: ShowLink~~
−	~~<syntaxhighlight lang="sputnik">~~
−	~~// 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~~
−	~~// The index part of the @IsLink is always the NAME of the~~
−	~~// variable minus the $& etc etc~~
	</syntaxhighlight>		</syntaxhighlight>

UberFoX: /* Important Examples */

2014-03-17T05:15:46Z

Important Examples

← Older revision		Revision as of 05:15, 17 March 2014
Line 16:		Line 16:

	==== Important Examples ====		==== Important Examples ====
		+
		+	===== Parameters as pointers =====
		+
		+	You can pass variables as a pointer to a function so the function can modify them variables directly rather than work on a copy of them.
		+
		+	The only real benefit of doing this is it speeds up execution time by not having to copy the variable.
		+
		+	This is only useful when used on arrays especially very big arrays.
		+
		+	To make a pointer you use & like in C++ and place it in parameter section of the function.
		+
		+	<syntaxhighlight lang="sputnik">
		+	// 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!";
		+	}
		+	</syntaxhighlight>

	===== Unlimited Function Parameters =====		===== Unlimited Function Parameters =====

UberFoX: /* Unlimited Function Parameters */

2013-09-12T06:09:27Z

Unlimited Function Parameters

← Older revision		Revision as of 06:09, 12 September 2013
Line 42:		Line 42:

	Note - If outside a function @args will return an empty array.		Note - If outside a function @args will return an empty array.
		+
		+	Since @args exists it is possible to use that as the function parameters... Example
		+	<syntaxhighlight lang="sputnik">
		+	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
		+	</syntaxhighlight>

	===== Function Rules =====		===== Function Rules =====