====== FUN ... ENDFUN ======

//Since version 2.2//

Syntax:

  fun <fun_name><sigil> [(<arg1>, <arg2>, <argn> ...)]
    [<statements>]
    return <expression>
  endfun
  
The ''FUN ... ENDFUN'' directives are used for defining a user function. Functions are similar to procedures with the exception that:

  * They **must** return a value.
  * They can be called from within an expression.

The name of the function and the name of a parameter **can't** start with a command or directive name. For example, you can't define a function named ''repeatnumber'' as ''REPEAT'' is a command. Likewise, you can't name a parameter ''funparameter1'' as ''FUN'' is a directive.

===== Defining functions =====

Define your functions /before/ calling them, preferably in the beginning of your source file, like in the example bellow:

  fun sum_of_integers(a, b)
    return a + b
  endfun
  
To define a function of a type other than integer as well as defining parameters other than integers, use sigils:

  fun sum_of_bytes!(a!, b!)
    return a! + b!
  endfun  
  
It is valid to have more than one ''RETURN'' statements in a function:

  fun max(a, b)
    if a > b then
      return a
    else
      return b
    endif
  endfun
  
Note there are no such things as void functions in **XC=BASIC** and the following will not work:

  fun dont_do_this(x)
    rem -- no return statement
  endfun
  
If you want a routine that does not return a value, use [[procedures|]] instead.

==== Parameterless functions ====

You can omit the parameter list, but bear in mind that you still have to write the empty parentheses:

  fun no_params()
    ...
  endfun
===== Calling functions =====

You can call a function from within an expression by using the function name, sigil and the argument list in parentheses, for example:

  let x! = my_function!(a, b!) * 2
  
Note that in the example above ''my_function!'' is a function that returns a byte and accepts an integer and a byte as arguments.

Important note: you must pass exactly the same amount of parameters and the parameter types must match those in the function definition.

===== Recursion =====

While procedures do support direct recursion, functions don't.