Functions

JSL also has a function called Function to extend the macro concept with a local context arguments. Suppose that you want to create a function that takes the square root but tolerates negative arguments, returning zero rather than errors. You first specify the local arguments in a list with braces { } and then state the expression directly. You do not need to enclose the expression in Expr because Function stores it as an expression implicitly.

myRoot = Function( {x},

	If( x > 0, Sqrt( x ), 0 )

);

a = myRoot( 4 );  // result is a is 2

b = myRoot( -1 ); // result is b is 0

Functions are stored in globals, the same as values. This means that you cannot have both a root function and a root value. It also means that you can redefine a function anytime except when you are inside the function itself.

When a function is called, its arguments are evaluated and given to the local variables specified in the list forming the first argument. Then the body of the function, the second argument, is evaluated.

The values of the arguments are for the temporary use of the function. When the function is exited, the values are discarded. The only value returned is the return value. If you want to return several values, then return a list instead of a single value.

In defined functions, the stored function is not accessible directly, even by the Name Expr command. If you need to access the function expression in your script, you have to create the function within an expr() clause. For example,

makeFunction = Expr(

	myRoot = Function( {x},

		If( x > 0, Sqrt( x ), 0 )

);

d = Substitute( Name Expr( MakeFunction ), Expr( x ), Expr( y ) );

Show( d );

makeFunction;

Optional Arguments

You can create optional arguments. For example:

f1 = Function( {x, y, z}); // all arguments are required

f2 = Function( {x, y=2, z=4}); // x is required, y and z are optional

Note the following:

•	To make a argument optional, give it a default value in the function's definition (x=1 rather than just x).

•	Optional arguments always must follow a required argument. For example, this is not allowed:

   Function( {x = 1, y}, ... )

It will work when defined, but you will always have to pass in a value for x and y, because the default value will never be used.

•	When you call the function, you cannot skip optional arguments. In this example, you have to supply a value for y to supply a value for z when you call the function:

ex = Function( {x, y = 2, z = 3},

	Return( x + y + z )

);

ex( 1, 4 ); // passes in 1 for x and 4 for y; z will be 3. returns 8.

Local Symbols

You can declare variables as local to a function so that they do not affect the global symbol space. This is particularly useful for recursive functions, which need to keep separate the values of the local variables at each level of function call evaluation.

As shown above, a function definition looks as follows:

functionName=Function({arg1, ...}, body);

You can also have the function definition default all the unscoped names to be local.

functionName=Function({arg1, ...}, {Default Local}, body);

The use of Default Local localizes all the names that:

•	Are not scoped as globals (for example, ::name)

•	Are not scoped as data table column names (for example, :name)

•	Occur without parentheses after them (for example, are not of the form name(...))

For example, the following function sums three numbers.

add3 = Function( {a, b, c},

	{temp},

	temp = a + b;

	temp + c;

);

X = add3( 1, 5, 9 );

The following function does the same thing, automatically finding locals.

add3 = Function( {a, b, c},

	{Default Local},

	temp = a + b;

	temp + c;

);

X = add3( 1, 5, 9 );

In both cases, the variable temp is not a global, or, if it is already a global, remains untouched by evaluating the functions.

Note: If you use an expression initially as local, then use it as a global, JSL changes the context. However, an expression used globally stays resolved globally regardless of its future use.

Using Default Local() in user-defined functions can cause some confusion because it is context-sensitive. That is, the same function may behave differently in different contexts, depending on whether same-named outer variables are in scope. The user should enumerate each and every variable they wish to be local. This reduces the confusion and the potential incorrect use of outer scope variable values.