Function (computer programming): Difference between revisions

Revision as of 21:42, 11 July 2025

Revision as of 01:03, 17 July 2025

Line 220:

In many contexts, a callable may have [[side-effect (computer science)|side effect]] behavior such as modifying passed or global data, reading from or writing to a [[peripheral device]], accessing a [[computer file|file]], halting the program or the machine, or temporarily pausing program execution.

Side effects are considered undesirebleundesirable by [[Robert C. Martin]], who is known for promoting design principles. Martin argues that side effects can result in [[sequential coupling|temporal coupling]] or order dependencies.<ref name="clean code">{{cite book |last1=Martin |first1=Robert C. |title=Clean Code: A Handbook of Agile Software Craftsmanship |date=Aug 1, 2008 |publisher=[[Pearson PLC|Pearson]] |isbn=9780132350884 |edition=1 |url=https://www.oreilly.com/library/view/clean-code-a/9780136083238/ |access-date=19 May 2024}}</ref>

In strictly [[functional programming]] languages such as [[Haskell (programming language)|Haskell]], a function can have no [[Side effect (computer science)|side effects]], which means it cannot change the state of the program. Functions always return the same result for the same input. Such languages typically only support functions that return a value, since there is no value in a function that has neither return value nor side effect.

Line 232:

=== Nested call {{endash}} recursion ===

If supported by the language, a callable may call itself, causing its execution to suspend while another ''nested'' execution of the same callable executes. [[Recursion (computer science)|Recursion]] is a useful means to simplify some complex algorithms and break down complex problems. Recursive languages provide a new copy of local variables on each call. If the programmer desires the recursive callable to use the same variables instead of using locals, they typically declare them in a shared context such static or global.

Languages going back to [[ALGOL]], [[PL/I]] and [[C (programming language)|C]] and modern languages, almost invariably use a call stack, usually supported by the instruction sets to provide an activation record for each call. That way, a nested call can modify its local variables without affecting any of the suspended calls variables.

Recursion allows direct implementation of functionality defined by [[mathematical induction]] and recursive [[divide and conquer algorithm]]s. Here is an example of a recursive function in C/C++ to find [[Fibonacci]] sequence|Fibonacci numbers]]:

<syntaxhighlight lang="c">

Line 254:

Some languages, e.g., [[Ada (programming language)|Ada]], [[Pascal (programming language)|Pascal]], [[PL/I]], [[Python (programming language)|Python]], support declaring and defining a function inside, e.g., a function body, such that the name of the inner is only visible within the body of the outer.

<!-- Would an example be helpful here? -->

A simple example in Pascal:<syntaxhighlight lang="pascal">function E(x: real): real;

function F(y: real): real;

begin

F := x + y

end;

begin

E := F(3) + F(4)

end;</syntaxhighlight>The function <code>F</code> is nested within <code>E</code>. Note that <code>E</code>'s parameter <code>x</code> is also visible in <code>F</code> (as <code>F</code> is a part of <code>E</code>) while both <code>x</code> and <code>y</code> are invisible outside <code>E</code> and <code>F</code> respectively.

=== Reentrancy ===