Function definition
Basic definition
With functions is lot of fun. Their definition starts with keyword fun
followed by its name and arguments list in parenthesis. Then follows function body enclosed in braces which contains function statements. There are two valid function statements. First is constant definition, second is return expression which should be last statement and it is return
keyword followed by return expression.
Input
1 2 3 4 5 6 7 8 9 10 11 12 | // function definition example 01 fun one() { return 1; } let x = one(); fun twoTimes(x) { return x * 2; } let y = twoTimes(4); process Constants with ConstantDumper; |
Output
x = 1; y = 8;
Local constant definition.
Input
1 2 3 4 5 6 7 8 9 | // function definition example 02 fun pythagoras(a, b) { let a2 = a*a; let b2 = b*b; return sqrt(a2 + b2); } let x = pythagoras(3, 4); process Constants with ConstantDumper; |
Output
x = 5;
Function's parameters can have their default values.
Input
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | // function definition example 03 fun add(a, b = 0) { return a + b; } let w = add(1, 2); let x = add(5); fun power(x = sqrt(2)) { return x * x; } let y = power(4); let z = power(); process Constants with ConstantDumper; |
Output
w = 3; x = 5; y = 16; z = 2;
Global and local scope
Function can be defined on both local or global scopes and they behave in the same way like constants (local definitions overlays global).
Input
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | // function definition example 04 fun alpha() { return 1; } fun beta() { return -1; } lsystem Lsystem1 { fun beta() { return 7; } set symbols axiom = A(alpha()) B(beta()); } lsystem Lsystem2 { set symbols axiom = C(alpha()) D(beta()); } process all with SymbolPrinter; |
Output
A(1) B(7)
C(1) D(-1)
Parameters overlays constants
Parameters have greater precedence than any constants. Local constants overlays parameters.
Input
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | // function definition example 05 let x = 7; fun alpha(x) { return x; } let a = alpha(0); fun beta(x) { let x = 1; return x; } let b = beta(0); process Constants with ConstantDumper; |
Output
a = 0; b = 1; x = 7;
Inheritance of functions
Inheritance of functions works as expected. Functions from derived L-systems are defined and new functions can redefine them.
Input
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | // function definition example 06 abstract lsystem Base { fun a() { return 1; } fun b() { return 2; } } lsystem Derived extends Base { fun a() { return 3; } set symbols axiom = A(a()) B(b()); } process all with SymbolPrinter; |
Output
A(3) B(2)
Formal grammar
Defines function with name represented by ID
, parameters params_list
, local constants constant_def
and return value expression
.
1 2 | function_def = 'fun' ID '(' params_list? ')' '{' constant_def* 'return' expression ';' '}' params_list = ID ('=' expression)? (',' params_list)? |