Evaluation strategy
Programming language evaluation rules
- 27 min read
- 5 chapters
Learn it on Lably
Just like in mathematics, evaluation is the process of finding the value corresponding to an expression.
The calling convention consists of the low-level platform-specific details of parameter passing.
Example
To illustrate, executing a function call f(a, b) may first evaluate the arguments a and b, store the results in references or memory locations ref_a and ref_b, then evaluate the function's body with those references passed in. This gives the function the ability to look up the original argument values passed in through dereferencing the parameters (some languages use specific operators to perform this), to modify them via assignment as if they were local variables, and to return values via the references. This is the call-by-reference evaluation strategy.
Sign in to keep reading
4 more chapters are free with a Lably account.
Table
This is a table of evaluation strategies and representative languages by year introduced. The representative languages are listed in chronological order, starting with the language(s) that introduced the strategy and followed by prominent languages that use the strategy.
Evaluation orders
While the order of operations defines the abstract syntax tree of the expression, the evaluation order defines the order in which expressions are evaluated. For example, the Python program
<span id="mwzg"></span><span class="k" id="mwzw">def</span><span class="w" id="mw0A"> </span><span class="nf" id="mw0Q">f</span><span class="p" id="mw0g">(</span><span class="n" id="mw0w">x</span><span class="p" id="mw1A">):</span> <span class="nb" id="mw1Q">print</span><span class="p" id="mw1g">(</span><span class="n" id="mw1w">x</span><span class="p" id="mw2A">,</span> <span class="n" id="mw2Q">end</span><span class="o" id="mw2g">=</span><span class="s2" id="mw2w">""</span><span class="p" id="mw3A">)</span> <span class="k" id="mw3Q">return</span> <span class="n" id="mw3g">x</span> <span class="nb" id="mw3w">print</span><span class="p" id="mw4A">(</span><span class="n" id="mw4Q">f</span><span class="p" id="mw4g">(</span><span class="mi" id="mw4w">1</span><span class="p" id="mw5A">)</span> <span class="o" id="mw5Q">+</span> <span class="n" id="mw5g">f</span><span class="p" id="mw5w">(</span><span class="mi" id="mw6A">2</span><span class="p" id="mw6Q">))</span>
outputs 123 due to Python's left-to-right evaluation order, but a similar program in OCaml:
<span id="mw7w"></span><span class="k" id="mw8A">let</span> <span class="n" id="mw8Q">f</span> <span class="n" id="mw8g">x</span> <span class="o" id="mw8w">=</span> <span class="n" id="mw9A">print_int</span> <span class="n" id="mw9Q">x</span><span class="o" id="mw9g">;</span> <span class="n" id="mw9w">x</span> <span class="o" id="mw-A">;;</span> <span class="n" id="mw-Q">print_int</span> <span class="o" id="mw-g">(</span><span class="n" id="mw-w">f</span> <span class="mi" id="mw_A">1</span> <span class="o" id="mw_Q">+</span> <span class="n" id="mw_g">f</span> <span class="mi" id="mw_w">2</span><span class="o" id="mwAQA">)</span>
outputs 213 due to OCaml's right-to-left evaluation order.
The evaluation order is mainly visible in code with side effects, but it also affects the performance of the code because a rigid order inhibits instruction scheduling. For this reason language standards such as C++ traditionally left the order unspecified, although languages such as Java and C# define the evaluation order as left-to-right and the C++17 standard has added constraints on the evaluation order.
Strict evaluation
Applicative order is a family of evaluation orders in which a function's arguments are evaluated completely before the function is applied. This has the effect of making the function strict, i.e. the function's result is undefined if any of the arguments are undefined, so applicative order evaluation is more commonly called strict evaluation. Furthermore, a function call is performed as soon as it is encountered in a procedure, so it is also called eager evaluation or greedy evaluation. Some authors refer to strict evaluation as "call by value" due to the call-by-value binding strategy requiring strict evaluation.
Common Lisp, Eiffel and Java evaluate function arguments left-to-right. C leaves the order undefined. Scheme requires the execution order to be the sequential execution of an unspecified permutation of the arguments. OCaml similarly leaves the order unspecified, but in practice evaluates arguments right-to-left due to the design of its abstract machine. All of these are strict evaluation.
Non-strict evaluation
A non-strict evaluation order is an evaluation order that is not strict, that is, a function may return a result before all of its arguments are fully evaluated. The prototypical example is normal order evaluation, which does not evaluate any of the arguments until they are needed in the body of the function. Normal order evaluation has the property that it terminates without error whenever any other evaluation order would have terminated without error. The name "normal order" comes from the lambda calculus, where normal order reduction will find a normal form if there is one (it is a "normalizing" reduction strategy). Lazy evaluation is classified in this article as a binding technique rather than an evaluation order. But this distinction is not always followed and some authors define lazy evaluation as normal order evaluation or vice-versa, or confuse non-strictness with lazy evaluation.
Boolean expressions in many languages use a form of non-strict evaluation called short-circuit evaluation, where evaluation evaluates the left expression but may skip the right expression if the result can be determined—for example, in a disjunctive expression (OR) where true is encountered, or in a conjunctive expression (AND) where false is encountered, and so forth. Conditional expressions similarly use non-strict evaluation - only one of the branches is evaluated.
Comparison of applicative order and normal order evaluation
With normal order evaluation, expressions containing an expensive computation, an error, or an infinite loop will be ignored if not needed, allowing the specification of user-defined control flow constructs, a facility not available with applicative order evaluation. Normal order evaluation uses complex structures such as thunks for unevaluated expressions, compared to the call stack used in applicative order evaluation. Normal order evaluation has historically had a lack of usable debugging tools due to its complexity.
Strict binding strategies
Call by value
In call by value (or pass by value), the evaluated value of the argument expression is bound to the corresponding variable in the function (frequently by copying the value into a new memory region). If the function or procedure is able to assign values to its parameters, only its local variable is assigned—that is, anything passed into a function call is unchanged in the caller's scope when the function returns. For example, in Pascal, passing an array by value will cause the entire array to be copied, and any mutations to this array will be invisible to the caller:
<span id="mwAYQ"></span><span class="k" id="mwAYU">program</span><span class="w" id="mwAYY"> </span><span class="n" id="mwAYc">Main</span><span class="o" id="mwAYg">;</span> <span class="k" id="mwAYk">uses</span><span class="w" id="mwAYo"> </span><span class="n" id="mwAYs">crt</span><span class="o" id="mwAYw">;</span> <span class="k" id="mwAY0">procedure</span><span class="w" id="mwAY4"> </span><span class="nf" id="mwAY8">PrintArray</span><span class="p" id="mwAZA">(</span><span class="n" id="mwAZE">a</span><span class="o" id="mwAZI">:</span><span class="w" id="mwAZM"> </span><span class="k" id="mwAZQ">Array</span><span class="w" id="mwAZU"> </span><span class="k" id="mwAZY">of</span><span class="w" id="mwAZc"> </span><span class="kt" id="mwAZg">integer</span><span class="p" id="mwAZk">)</span><span class="o" id="mwAZo">;</span> <span class="k" id="mwAZs">var</span> <span class="w" id="mwAZw"> </span><span class="n" id="mwAZ0">i</span><span class="o" id="mwAZ4">:</span><span class="w" id="mwAZ8"> </span><span class="kt" id="mwAaA">Integer</span><span class="o" id="mwAaE">;</span> <span class="k" id="mwAaI">begin</span> <span class="w" id="mwAaM"> </span><span class="k" id="mwAaQ">for</span><span class="w" id="mwAaU"> </span><span class="n" id="mwAaY">i</span><span class="w" id="mwAac"> </span><span class="o" id="mwAag">:=</span><span class="w" id="mwAak"> </span><span class="nb" id="mwAao">Low</span><span class="p" id="mwAas">(</span><span class="n" id="mwAaw">a</span><span class="p" id="mwAa0">)</span><span class="w" id="mwAa4"> </span><span class="k" id="mwAa8">to</span><span class="w" id="mwAbA"> </span><span class="nb" id="mwAbE">High</span><span class="p" id="mwAbI">(</span><span class="n" id="mwAbM">a</span><span class="p" id="mwAbQ">)</span><span class="w" id="mwAbU"> </span><span class="k" id="mwAbY">do</span> <span class="w" id="mwAbc"> </span><span class="nb" id="mwAbg">Write</span><span class="p" id="mwAbk">(</span><span class="n" id="mwAbo">a</span><span class="p" id="mwAbs">[</span><span class="n" id="mwAbw">i</span><span class="p" id="mwAb0">])</span><span class="o" id="mwAb4">;</span> <span class="w" id="mwAb8"> </span><span class="nb" id="mwAcA">WriteLn</span><span class="p" id="mwAcE">()</span><span class="o" id="mwAcI">;</span> <span class="k" id="mwAcM">end</span><span class="o" id="mwAcQ">;</span> <span class="k" id="mwAcU">Procedure</span><span class="w" id="mwAcY"> </span><span class="nf" id="mwAcc">Modify</span><span class="p" id="mwAcg">(</span><span class="n" id="mwAck">Row</span><span class="w" id="mwAco"> </span><span class="o" id="mwAcs">:</span><span class="w" id="mwAcw"> </span><span class="k" id="mwAc0">Array</span><span class="w" id="mwAc4"> </span><span class="k" id="mwAc8">of</span><span class="w" id="mwAdA"> </span><span class="kt" id="mwAdE">integer</span><span class="p" id="mwAdI">)</span><span class="o" id="mwAdM">;</span><span class="w" id="mwAdQ"> </span> <span class="k" id="mwAdU">begin</span><span class="w" id="mwAdY"> </span> <span class="w" id="mwAdc"> </span><span class="n" id="mwAdg">PrintArray</span><span class="p" id="mwAdk">(</span><span class="n" id="mwAdo">Row</span><span class="p" id="mwAds">)</span><span class="o" id="mwAdw">;</span><span class="w" id="mwAd0"> </span><span class="c1" id="mwAd4">// 123</span> <span class="w" id="mwAd8"> </span><span class="n" id="mwAeA">Row</span><span class="p" id="mwAeE">[</span><span class="mi" id="mwAeI">1</span><span class="p" id="mwAeM">]</span><span class="w" id="mwAeQ"> </span><span class="o" id="mwAeU">:=</span><span class="w" id="mwAeY"> </span><span class="mi" id="mwAec">4</span><span class="o" id="mwAeg">;</span> <span class="w" id="mwAek"> </span><span class="n" id="mwAeo">PrintArray</span><span class="p" id="mwAes">(</span><span class="n" id="mwAew">Row</span><span class="p" id="mwAe0">)</span><span class="o" id="mwAe4">;</span><span class="w" id="mwAe8"> </span><span class="c1" id="mwAfA">// 143</span> <span class="k" id="mwAfE">end</span><span class="o" id="mwAfI">;</span> <span class="k" id="mwAfM">Var</span> <span class="w" id="mwAfQ"> </span><span class="n" id="mwAfU">A</span><span class="w" id="mwAfY"> </span><span class="o" id="mwAfc">:</span><span class="w" id="mwAfg"> </span><span class="k" id="mwAfk">Array</span><span class="w" id="mwAfo"> </span><span class="k" id="mwAfs">of</span><span class="w" id="mwAfw"> </span><span class="kt" id="mwAf0">integer</span><span class="o" id="mwAf4">;</span><span class="w" id="mwAf8"> </span> <span class="k" id="mwAgA">begin</span> <span class="w" id="mwAgE"> </span><span class="n" id="mwAgI">A</span><span class="w" id="mwAgM"> </span><span class="o" id="mwAgQ">:=</span><span class="w" id="mwAgU"> </span><span class="p" id="mwAgY">[</span><span class="mi" id="mwAgc">1</span><span class="o" id="mwAgg">,</span><span class="mi" id="mwAgk">2</span><span class="o" id="mwAgo">,</span><span class="mi" id="mwAgs">3</span><span class="p" id="mwAgw">]</span><span class="o" id="mwAg0">;</span> <span class="w" id="mwAg4"> </span><span class="n" id="mwAg8">PrintArray</span><span class="p" id="mwAhA">(</span><span class="n" id="mwAhE">A</span><span class="p" id="mwAhI">)</span><span class="o" id="mwAhM">;</span><span class="w" id="mwAhQ"> </span><span class="c1" id="mwAhU">// 123</span> <span class="w" id="mwAhY"> </span><span class="n" id="mwAhc">Modify</span><span class="p" id="mwAhg">(</span><span class="n" id="mwAhk">A</span><span class="p" id="mwAho">)</span><span class="o" id="mwAhs">;</span> <span class="w" id="mwAhw"> </span><span class="n" id="mwAh0">PrintArray</span><span class="p" id="mwAh4">(</span><span class="n" id="mwAh8">A</span><span class="p" id="mwAiA">)</span><span class="o" id="mwAiE">;</span><span class="w" id="mwAiI"> </span><span class="c1" id="mwAiM">// 123</span> <span class="k" id="mwAiQ">end</span><span class="o" id="mwAiU">.</span>
Semantic drift
Strictly speaking, under call by value, no operations performed by the called routine can be visible to the caller, other than as part of the return value. This implies a form of purely functional programming in the implementation semantics. However, the circumlocution "call by value where the value is a reference" has become common in some languages, for example, the Java community. Compared to traditional pass by value, the value which is passed is not a value as understood by the ordinary meaning of value, such as an integer that can be written as a literal, but an implementation-internal reference handle. Mutations to this reference handle are visible in the caller. Due to the visible mutation, this form of "call by value" is more properly referred to as call by sharing.
In purely functional languages, values and data structures are immutable, so there is no possibility for a function to modify any of its arguments. As such, there is typically no semantic difference between passing by value and passing by reference or a pointer to the data structure, and implementations frequently use call by reference internally for the efficiency benefits. Nonetheless, these languages are typically described as call by value languages.
Call by reference
Call by reference (or pass by reference) is an evaluation strategy where a parameter is bound to an implicit reference to the variable used as argument, rather than a copy of its value. This typically means that the function can modify (i.e., assign to) the variable used as argument—something that will be seen by its caller. Call by reference can therefore be used to provide an additional channel of communication between the called function and the calling function. Pass by reference can significantly improve performance: calling a function with a many-megabyte structure as an argument does not have to copy the large structure, only the reference to the structure (which is generally a machine word and only a few bytes). However, a call-by-reference language makes it more difficult for a programmer to track the effects of a function call, and may introduce subtle bugs.
Due to variation in syntax, the difference between call by reference (where the reference type is implicit) and call by sharing (where the reference type is explicit) is often unclear on first glance. A simple litmus test is if it's possible to write a traditional swap(a, b) function in the language. For example in Fortran:
<span id="mwAkY"></span><span class="k" id="mwAkc">program </span><span class="n" id="mwAkg">Main</span> <span class="w" id="mwAkk"> </span><span class="k" id="mwAko">implicit none</span> <span class="k" id="mwAks"> </span><span class="kt" id="mwAkw">integer</span><span class="w" id="mwAk0"> </span><span class="kd" id="mwAk4">::</span><span class="w" id="mwAk8"> </span><span class="n" id="mwAlA">a</span><span class="w" id="mwAlE"> </span><span class="o" id="mwAlI">=</span><span class="w" id="mwAlM"> </span><span class="mi" id="mwAlQ">1</span> <span class="w" id="mwAlU"> </span><span class="kt" id="mwAlY">integer</span><span class="w" id="mwAlc"> </span><span class="kd" id="mwAlg">::</span><span class="w" id="mwAlk"> </span><span class="n" id="mwAlo">b</span><span class="w" id="mwAls"> </span><span class="o" id="mwAlw">=</span><span class="w" id="mwAl0"> </span><span class="mi" id="mwAl4">2</span> <span class="w" id="mwAl8"> </span><span class="k" id="mwAmA">call </span><span class="n" id="mwAmE">Swap</span><span class="p" id="mwAmI">(</span><span class="n" id="mwAmM">a</span><span class="p" id="mwAmQ">,</span><span class="w" id="mwAmU"> </span><span class="n" id="mwAmY">b</span><span class="p" id="mwAmc">)</span> <span class="w" id="mwAmg"> </span><span class="k" id="mwAmk">print</span><span class="w" id="mwAmo"> </span><span class="o" id="mwAms">*</span><span class="p" id="mwAmw">,</span><span class="w" id="mwAm0"> </span><span class="n" id="mwAm4">a</span><span class="p" id="mwAm8">,</span><span class="w" id="mwAnA"> </span><span class="n" id="mwAnE">b</span><span class="w" id="mwAnI"> </span><span class="c" id="mwAnM">! 2 1</span> <span class="k" id="mwAnQ">contains</span> <span class="k" id="mwAnU"> subroutine </span><span class="n" id="mwAnY">Swap</span><span class="p" id="mwAnc">(</span><span class="n" id="mwAng">a</span><span class="p" id="mwAnk">,</span><span class="w" id="mwAno"> </span><span class="n" id="mwAns">b</span><span class="p" id="mwAnw">)</span> <span class="w" id="mwAn0"> </span><span class="kt" id="mwAn4">integer</span><span class="p" id="mwAn8">,</span><span class="w" id="mwAoA"> </span><span class="k" id="mwAoE">intent</span><span class="p" id="mwAoI">(</span><span class="n" id="mwAoM">inout</span><span class="p" id="mwAoQ">)</span><span class="w" id="mwAoU"> </span><span class="kd" id="mwAoY">::</span><span class="w" id="mwAoc"> </span><span class="n" id="mwAog">a</span><span class="p" id="mwAok">,</span><span class="w" id="mwAoo"> </span><span class="n" id="mwAos">b</span> <span class="w" id="mwAow"> </span><span class="kt" id="mwAo0">integer</span><span class="w" id="mwAo4"> </span><span class="kd" id="mwAo8">::</span><span class="w" id="mwApA"> </span><span class="n" id="mwApE">temp</span> <span class="w" id="mwApI"> </span><span class="n" id="mwApM">temp</span><span class="w" id="mwApQ"> </span><span class="o" id="mwApU">=</span><span class="w" id="mwApY"> </span><span class="n" id="mwApc">a</span> <span class="w" id="mwApg"> </span><span class="n" id="mwApk">a</span><span class="w" id="mwApo"> </span><span class="o" id="mwAps">=</span><span class="w" id="mwApw"> </span><span class="n" id="mwAp0">b</span> <span class="w" id="mwAp4"> </span><span class="n" id="mwAp8">b</span><span class="w" id="mwAqA"> </span><span class="o" id="mwAqE">=</span><span class="w" id="mwAqI"> </span><span class="n" id="mwAqM">temp</span> <span class="w" id="mwAqQ"> </span><span class="k" id="mwAqU">end subroutine </span><span class="n" id="mwAqY">Swap</span> <span class="k" id="mwAqc">end program </span><span class="n" id="mwAqg">Main</span>
Therefore, Fortran's inout intent implements call-by-reference; any variable can be implicitly converted to a reference handle. In contrast the closest one can get in Java is:
<span id="mwAq0"></span><span class="kd" id="mwAq4">public</span><span class="w" id="mwAq8"> </span><span class="kd" id="mwArA">class</span> <span class="nc" id="mwArE">Main</span><span class="w" id="mwArI"> </span><span class="p" id="mwArM">{</span> <span class="w" id="mwArQ"> </span><span class="kd" id="mwArU">static</span><span class="w" id="mwArY"> </span><span class="kd" id="mwArc">class</span> <span class="nc" id="mwArg">Box</span><span class="w" id="mwArk"> </span><span class="p" id="mwAro">{</span> <span class="w" id="mwArs"> </span><span class="kt" id="mwArw">int</span><span class="w" id="mwAr0"> </span><span class="n" id="mwAr4">value</span><span class="p" id="mwAr8">;</span> <span class="w" id="mwAsA"> </span><span class="kd" id="mwAsE">public</span><span class="w" id="mwAsI"> </span><span class="nf" id="mwAsM">Box</span><span class="p" id="mwAsQ">(</span><span class="kt" id="mwAsU">int</span><span class="w" id="mwAsY"> </span><span class="n" id="mwAsc">value</span><span class="p" id="mwAsg">)</span><span class="w" id="mwAsk"> </span><span class="p" id="mwAso">{</span> <span class="w" id="mwAss"> </span><span class="k" id="mwAsw">this</span><span class="p" id="mwAs0">.</span><span class="na" id="mwAs4">value</span><span class="w" id="mwAs8"> </span><span class="o" id="mwAtA">=</span><span class="w" id="mwAtE"> </span><span class="n" id="mwAtI">value</span><span class="p" id="mwAtM">;</span> <span class="w" id="mwAtQ"> </span><span class="p" id="mwAtU">}</span> <span class="w" id="mwAtY"> </span><span class="p" id="mwAtc">}</span> <span class="w" id="mwAtg"> </span><span class="kd" id="mwAtk">static</span><span class="w" id="mwAto"> </span><span class="kt" id="mwAts">void</span><span class="w" id="mwAtw"> </span><span class="nf" id="mwAt0">swap</span><span class="p" id="mwAt4">(</span><span class="n" id="mwAt8">Box</span><span class="w" id="mwAuA"> </span><span class="n" id="mwAuE">a</span><span class="p" id="mwAuI">,</span><span class="w" id="mwAuM"> </span><span class="n" id="mwAuQ">Box</span><span class="w" id="mwAuU"> </span><span class="n" id="mwAuY">b</span><span class="p" id="mwAuc">)</span><span class="w" id="mwAug"> </span><span class="p" id="mwAuk">{</span> <span class="w" id="mwAuo"> </span><span class="kt" id="mwAus">int</span><span class="w" id="mwAuw"> </span><span class="n" id="mwAu0">temp</span><span class="w" id="mwAu4"> </span><span class="o" id="mwAu8">=</span><span class="w" id="mwAvA"> </span><span class="n" id="mwAvE">a</span><span class="p" id="mwAvI">.</span><span class="na" id="mwAvM">value</span><span class="p" id="mwAvQ">;</span> <span class="w" id="mwAvU"> </span><span class="n" id="mwAvY">a</span><span class="p" id="mwAvc">.</span><span class="na" id="mwAvg">value</span><span class="w" id="mwAvk"> </span><span class="o" id="mwAvo">=</span><span class="w" id="mwAvs"> </span><span class="n" id="mwAvw">b</span><span class="p" id="mwAv0">.</span><span class="na" id="mwAv4">value</span><span class="p" id="mwAv8">;</span> <span class="w" id="mwAwA"> </span><span class="n" id="mwAwE">b</span><span class="p" id="mwAwI">.</span><span class="na" id="mwAwM">value</span><span class="w" id="mwAwQ"> </span><span class="o" id="mwAwU">=</span><span class="w" id="mwAwY"> </span><span class="n" id="mwAwc">temp</span><span class="p" id="mwAwg">;</span> <span class="w" id="mwAwk"> </span><span class="p" id="mwAwo">}</span> <span class="w" id="mwAws"> </span><span class="kd" id="mwAww">public</span><span class="w" id="mwAw0"> </span><span class="kd" id="mwAw4">static</span><span class="w" id="mwAw8"> </span><span class="kt" id="mwAxA">void</span><span class="w" id="mwAxE"> </span><span class="nf" id="mwAxI">main</span><span class="p" id="mwAxM">(</span><span class="n" id="mwAxQ">String</span><span class="o" id="mwAxU">[]</span><span class="w" id="mwAxY"> </span><span class="n" id="mwAxc">args</span><span class="p" id="mwAxg">)</span><span class="w" id="mwAxk"> </span><span class="p" id="mwAxo">{</span> <span class="w" id="mwAxs"> </span><span class="n" id="mwAxw">Box</span><span class="w" id="mwAx0"> </span><span class="n" id="mwAx4">a</span><span class="w" id="mwAx8"> </span><span class="o" id="mwAyA">=</span><span class="w" id="mwAyE"> </span><span class="k" id="mwAyI">new</span><span class="w" id="mwAyM"> </span><span class="n" id="mwAyQ">Box</span><span class="p" id="mwAyU">(</span><span class="mi" id="mwAyY">1</span><span class="p" id="mwAyc">);</span> <span class="w" id="mwAyg"> </span><span class="n" id="mwAyk">Box</span><span class="w" id="mwAyo"> </span><span class="n" id="mwAys">b</span><span class="w" id="mwAyw"> </span><span class="o" id="mwAy0">=</span><span class="w" id="mwAy4"> </span><span class="k" id="mwAy8">new</span><span class="w" id="mwAzA"> </span><span class="n" id="mwAzE">Box</span><span class="p" id="mwAzI">(</span><span class="mi" id="mwAzM">2</span><span class="p" id="mwAzQ">);</span> <span class="w" id="mwAzU"> </span><span class="n" id="mwAzY">swap</span><span class="p" id="mwAzc">(</span><span class="n" id="mwAzg">a</span><span class="p" id="mwAzk">,</span><span class="w" id="mwAzo"> </span><span class="n" id="mwAzs">b</span><span class="p" id="mwAzw">);</span> <span class="w" id="mwAz0"> </span><span class="n" id="mwAz4">System</span><span class="p" id="mwAz8">.</span><span class="na" id="mwA0A">out</span><span class="p" id="mwA0E">.</span><span class="na" id="mwA0I">printf</span><span class="p" id="mwA0M">(</span><span class="s" id="mwA0Q">"a = %d, b = %d%n"</span><span class="p" id="mwA0U">,</span><span class="w" id="mwA0Y"> </span><span class="n" id="mwA0c">a</span><span class="p" id="mwA0g">.</span><span class="na" id="mwA0k">value</span><span class="p" id="mwA0o">,</span><span class="w" id="mwA0s"> </span><span class="n" id="mwA0w">b</span><span class="p" id="mwA00">.</span><span class="na" id="mwA04">value</span><span class="p" id="mwA08">);</span> <span class="w" id="mwA1A"> </span><span class="c1" id="mwA1E">// output: a = 2, b = 1</span> <span class="w" id="mwA1I"> </span><span class="p" id="mwA1M">}</span> <span class="p" id="mwA1Q">}</span>where an explicit Box type must be used to introduce a handle. Java is call-by-sharing but not call-by-reference.
Call by copy-restore
Call by copy-restore—also known as "copy-in copy-out", "call by value result", "call by value return" (as termed in the Fortran community)—is a variation of call by reference. With call by copy-restore, the contents of the argument are copied to a new variable local to the call invocation. The function may then modify this variable, similarly to call by reference, but as the variable is local, the modifications are not visible outside of the call invocation during the call. When the function call returns, the updated contents of this variable are copied back to overwrite the original argument ("restored").
The semantics of call by copy-restore is similar in many cases to call by reference, but differs when two or more function arguments alias one another (i.e., point to the same variable in the caller's environment). Under call by reference, writing to one argument will affect the other during the function's execution. Under call by copy-restore, writing to one argument will not affect the other during the function's execution, but at the end of the call, the values of the two arguments may differ, and it is unclear which argument is copied back first and therefore what value the caller's variable receives. For example, Ada specifies that the copy-out assignment for each in out or out parameter occurs in an arbitrary order. From the following program (illegal in Ada 2012) it can be seen that the behavior of GNAT is to copy in left-to-right order on return:
<span id="mwA3U"></span><span class="kn" id="mwA3Y">with</span> <span class="n" id="mwA3c">Ada.Text_IO</span><span class="p" id="mwA3g">;</span> <span class="kn" id="mwA3k">use</span> <span class="n" id="mwA3o">Ada.Text_IO</span><span class="p" id="mwA3s">;</span> <span class="kd" id="mwA3w">procedure</span> <span class="nf" id="mwA30">Test_Copy_Restore</span> <span class="kr" id="mwA34">is</span> <span class="kd" id="mwA38">procedure</span> <span class="nf" id="mwA4A">Modify</span> <span class="p" id="mwA4E">(</span><span class="nv" id="mwA4I">A</span><span class="p" id="mwA4M">,</span> <span class="nv" id="mwA4Q">B</span> <span class="p" id="mwA4U">: </span><span class="nv" id="mwA4Y">in</span> <span class="nv" id="mwA4c">out</span> <span class="nv" id="mwA4g">Integer</span><span class="p" id="mwA4k">)</span> <span class="kr" id="mwA4o">is</span> <span class="kr" id="mwA4s">begin</span> <span class="n" id="mwA4w">A</span> <span class="p" id="mwA40">:=</span> <span class="n" id="mwA44">A</span> <span class="o" id="mwA48">+</span> <span class="mi" id="mwA5A">1</span><span class="p" id="mwA5E">;</span> <span class="n" id="mwA5I">B</span> <span class="p" id="mwA5M">:=</span> <span class="n" id="mwA5Q">B</span> <span class="o" id="mwA5U">+</span> <span class="mi" id="mwA5Y">2</span><span class="p" id="mwA5c">;</span> <span class="kr" id="mwA5g">end</span> <span class="nf" id="mwA5k">Modify</span><span class="p" id="mwA5o">;</span> <span class="n" id="mwA5s">X</span> <span class="p" id="mwA5w">:</span> <span class="kt" id="mwA50">Integer</span> <span class="p" id="mwA54">:=</span> <span class="mi" id="mwA58">0</span><span class="p" id="mwA6A">;</span> <span class="kr" id="mwA6E">begin</span> <span class="n" id="mwA6I">Modify</span><span class="p" id="mwA6M">(</span><span class="n" id="mwA6Q">X</span><span class="p" id="mwA6U">,</span> <span class="n" id="mwA6Y">X</span><span class="p" id="mwA6c">);</span> <span class="n" id="mwA6g">Put_Line</span><span class="p" id="mwA6k">(</span><span class="s" id="mwA6o">"X = "</span> <span class="o" id="mwA6s">&</span> <span class="kt" id="mwA6w">Integer</span><span class="p" id="mwA60">'</span><span class="na" id="mwA64">Image</span><span class="p" id="mwA68">(</span><span class="n" id="mwA7A">X</span><span class="p" id="mwA7E">));</span> <span class="kr" id="mwA7I">end</span> <span class="nf" id="mwA7M">Test_Copy_Restore</span><span class="p" id="mwA7Q">;</span> <span class="c1" id="mwA7U">-- $ gnatmake -gnatd.E test_copy_restore.adb; ./test_copy_restore</span> <span class="c1" id="mwA7Y">-- test_copy_restore.adb:12:10: warning: writable actual for "A" overlaps with actual for "B" [-gnatw.i]</span> <span class="c1" id="mwA7c">-- X = 2</span>
If the program returned 1 it would be copying right-to-left, and under call by reference semantics the program would return 3.
When the reference is passed to the caller uninitialized (for example an out parameter in Ada as opposed to an in out parameter), this evaluation strategy may be called "call by result".
This strategy has gained attention in multiprocessing and remote procedure calls, as unlike call-by-reference it does not require frequent communication between threads of execution for variable access.
Call by sharing
Call by sharing (also known as "pass by sharing", "call by object", or "call by object-sharing") is an evaluation strategy that is intermediate between call by value and call by reference. Rather than every variable being exposed as a reference, only a specific class of values, termed "references", "boxed types", or "objects", have reference semantics, and it is the addresses of these pointers that are passed into the function. Like call by value, the value of the address passed is a copy, and direct assignment to the parameter of the function overwrites the copy and is not visible to the calling function. Like call by reference, mutating the target of the pointer is visible to the calling function. Mutations of a mutable object within the function are visible to the caller because the object is not copied or cloned—it is shared, hence the name "call by sharing".
The technique was first noted by Barbara Liskov in 1974 for the CLU language. It is used by many modern languages such as Python (the shared values being called "objects"), Java (objects), Ruby (objects), JavaScript (objects), Scheme (data structures such as vectors), AppleScript (lists, records, dates, and script objects), OCaml and ML (references, records, arrays, objects, and other compound data types), Maple (rtables and tables), and Tcl (objects). The term "call by sharing" as used in this article is not in common use; the terminology is inconsistent across different sources. For example, in the Java community, they say that Java is call by value.
For immutable objects, there is no real difference between call by sharing and call by value, except if object identity is visible in the language. The use of call by sharing with mutable objects is an alternative to input/output parameters: the parameter is not assigned to (the argument is not overwritten and object identity is not changed), but the object (argument) is mutated.
For example, in Python, lists are mutable and passed with call by sharing, so:
<span id="mwA_U"></span><span class="k" id="mwA_Y">def</span><span class="w" id="mwA_c"> </span><span class="nf" id="mwA_g">f</span><span class="p" id="mwA_k">(</span><span class="n" id="mwA_o">l</span><span class="p" id="mwA_s">:</span> <span class="nb" id="mwA_w">list</span><span class="p" id="mwA_0">[</span><span class="nb" id="mwA_4">int</span><span class="p" id="mwA_8">])</span> <span class="o" id="mwBAA">-></span> <span class="kc" id="mwBAE">None</span><span class="p" id="mwBAI">:</span> <span class="n" id="mwBAM">l</span><span class="o" id="mwBAQ">.</span><span class="n" id="mwBAU">append</span><span class="p" id="mwBAY">(</span><span class="mi" id="mwBAc">1</span><span class="p" id="mwBAg">)</span> <span class="n" id="mwBAk">m</span><span class="p" id="mwBAo">:</span> <span class="nb" id="mwBAs">list</span><span class="p" id="mwBAw">[</span><span class="nb" id="mwBA0">int</span><span class="p" id="mwBA4">]</span> <span class="o" id="mwBA8">=</span> <span class="p" id="mwBBA">[]</span> <span class="n" id="mwBBE">f</span><span class="p" id="mwBBI">(</span><span class="n" id="mwBBM">m</span><span class="p" id="mwBBQ">)</span> <span class="nb" id="mwBBU">print</span><span class="p" id="mwBBY">(</span><span class="n" id="mwBBc">m</span><span class="p" id="mwBBg">)</span>
outputs [1] because the append method modifies the object on which it is called.
In contrast, assignments within a function are not noticeable to the caller. For example, this code binds the formal argument to a new object, but it is not visible to the caller because it does not mutate a_list:
<span id="mwBCA"></span><span class="k" id="mwBCE">def</span><span class="w" id="mwBCI"> </span><span class="nf" id="mwBCM">f</span><span class="p" id="mwBCQ">(</span><span class="n" id="mwBCU">l</span><span class="p" id="mwBCY">:</span> <span class="nb" id="mwBCc">list</span><span class="p" id="mwBCg">[</span><span class="nb" id="mwBCk">int</span><span class="p" id="mwBCo">])</span> <span class="o" id="mwBCs">-></span> <span class="kc" id="mwBCw">None</span><span class="p" id="mwBC0">:</span> <span class="n" id="mwBC4">l</span> <span class="o" id="mwBC8">=</span> <span class="n" id="mwBDA">l</span> <span class="o" id="mwBDE">+</span> <span class="p" id="mwBDI">[</span><span class="mi" id="mwBDM">1</span><span class="p" id="mwBDQ">]</span> <span class="nb" id="mwBDU">print</span><span class="p" id="mwBDY">(</span><span class="n" id="mwBDc">l</span><span class="p" id="mwBDg">)</span> <span class="c1" id="mwBDk"># [1]</span> <span class="n" id="mwBDo">m</span><span class="p" id="mwBDs">:</span> <span class="nb" id="mwBDw">list</span><span class="p" id="mwBD0">[</span><span class="nb" id="mwBD4">int</span><span class="p" id="mwBD8">]</span> <span class="o" id="mwBEA">=</span> <span class="p" id="mwBEE">[]</span> <span class="n" id="mwBEI">f</span><span class="p" id="mwBEM">(</span><span class="n" id="mwBEQ">m</span><span class="p" id="mwBEU">)</span> <span class="nb" id="mwBEY">print</span><span class="p" id="mwBEc">(</span><span class="n" id="mwBEg">m</span><span class="p" id="mwBEk">)</span> <span class="c1" id="mwBEo"># []</span>
Call by address
Call by address, pass by address, or call/pass by pointer is a parameter passing method where the address of the argument is passed as the formal parameter. Inside the function, the address (pointer) may be used to access or modify the value of the argument. For example, the swap operation can be implemented as follows in C:
<span id="mwBFU"></span><span class="cp" id="mwBFY">#include</span><span class="w" id="mwBFc"> </span><span class="cpf" id="mwBFg"><stdio.h></span> <span class="kt" id="mwBFk">void</span><span class="w" id="mwBFo"> </span><span class="nf" id="mwBFs">swap</span><span class="p" id="mwBFw">(</span><span class="kt" id="mwBF0">int</span><span class="o" id="mwBF4">*</span><span class="w" id="mwBF8"> </span><span class="n" id="mwBGA">a</span><span class="p" id="mwBGE">,</span><span class="w" id="mwBGI"> </span><span class="kt" id="mwBGM">int</span><span class="o" id="mwBGQ">*</span><span class="w" id="mwBGU"> </span><span class="n" id="mwBGY">b</span><span class="p" id="mwBGc">)</span><span class="w" id="mwBGg"> </span><span class="p" id="mwBGk">{</span> <span class="w" id="mwBGo"> </span><span class="kt" id="mwBGs">int</span><span class="w" id="mwBGw"> </span><span class="n" id="mwBG0">temp</span><span class="w" id="mwBG4"> </span><span class="o" id="mwBG8">=</span><span class="w" id="mwBHA"> </span><span class="o" id="mwBHE">*</span><span class="n" id="mwBHI">a</span><span class="p" id="mwBHM">;</span> <span class="w" id="mwBHQ"> </span><span class="o" id="mwBHU">*</span><span class="n" id="mwBHY">a</span><span class="w" id="mwBHc"> </span><span class="o" id="mwBHg">=</span><span class="w" id="mwBHk"> </span><span class="o" id="mwBHo">*</span><span class="n" id="mwBHs">b</span><span class="p" id="mwBHw">;</span> <span class="w" id="mwBH0"> </span><span class="o" id="mwBH4">*</span><span class="n" id="mwBH8">b</span><span class="w" id="mwBIA"> </span><span class="o" id="mwBIE">=</span><span class="w" id="mwBII"> </span><span class="n" id="mwBIM">temp</span><span class="p" id="mwBIQ">;</span> <span class="p" id="mwBIU">}</span> <span class="kt" id="mwBIY">int</span><span class="w" id="mwBIc"> </span><span class="nf" id="mwBIg">main</span><span class="p" id="mwBIk">()</span><span class="w" id="mwBIo"> </span><span class="p" id="mwBIs">{</span> <span class="w" id="mwBIw"> </span><span class="kt" id="mwBI0">int</span><span class="w" id="mwBI4"> </span><span class="n" id="mwBI8">a</span><span class="w" id="mwBJA"> </span><span class="o" id="mwBJE">=</span><span class="w" id="mwBJI"> </span><span class="mi" id="mwBJM">1</span><span class="p" id="mwBJQ">;</span> <span class="w" id="mwBJU"> </span><span class="kt" id="mwBJY">int</span><span class="w" id="mwBJc"> </span><span class="n" id="mwBJg">b</span><span class="w" id="mwBJk"> </span><span class="o" id="mwBJo">=</span><span class="w" id="mwBJs"> </span><span class="mi" id="mwBJw">2</span><span class="p" id="mwBJ0">;</span> <span class="w" id="mwBJ4"> </span><span class="n" id="mwBJ8">swap</span><span class="p" id="mwBKA">(</span><span class="o" id="mwBKE">&</span><span class="n" id="mwBKI">a</span><span class="p" id="mwBKM">,</span><span class="w" id="mwBKQ"> </span><span class="o" id="mwBKU">&</span><span class="n" id="mwBKY">b</span><span class="p" id="mwBKc">);</span> <span class="w" id="mwBKg"> </span><span class="n" id="mwBKk">printf</span><span class="p" id="mwBKo">(</span><span class="s" id="mwBKs">"%d %d</span><span class="se" id="mwBKw">\n</span><span class="s" id="mwBK0">"</span><span class="p" id="mwBK4">,</span><span class="w" id="mwBK8"> </span><span class="n" id="mwBLA">a</span><span class="p" id="mwBLE">,</span><span class="w" id="mwBLI"> </span><span class="n" id="mwBLM">b</span><span class="p" id="mwBLQ">);</span><span class="w" id="mwBLU"> </span><span class="c1" id="mwBLY">// 2 1</span> <span class="w" id="mwBLc"> </span><span class="k" id="mwBLg">return</span><span class="w" id="mwBLk"> </span><span class="mi" id="mwBLo">0</span><span class="p" id="mwBLs">;</span> <span class="p" id="mwBLw">}</span>Some authors treat & as part of the syntax of calling swap. Under this view, C supports the call-by-reference parameter passing strategy. Other authors take a differing view that the presented implementation of swap in C is only a simulation of call-by-reference using pointers. Under this "simulation" view, mutable variables in C are not first-class (that is, l-values are not expressions), rather pointer types are. In this view, the presented swap program is syntactic sugar for a program that uses pointers throughout, for example this program (read and assign have been added to highlight the similarities to the Java Box call-by-sharing program above):
<span id="mwBNQ"></span><span class="cp" id="mwBNU">#include</span><span class="w" id="mwBNY"> </span><span class="cpf" id="mwBNc"><stdio.h></span> <span class="kt" id="mwBNg">int</span><span class="w" id="mwBNk"> </span><span class="nf" id="mwBNo">read</span><span class="p" id="mwBNs">(</span><span class="kt" id="mwBNw">int</span><span class="o" id="mwBN0">*</span><span class="w" id="mwBN4"> </span><span class="n" id="mwBN8">p</span><span class="p" id="mwBOA">)</span><span class="w" id="mwBOE"> </span><span class="p" id="mwBOI">{</span> <span class="w" id="mwBOM"> </span><span class="k" id="mwBOQ">return</span><span class="w" id="mwBOU"> </span><span class="o" id="mwBOY">*</span><span class="n" id="mwBOc">p</span><span class="p" id="mwBOg">;</span> <span class="p" id="mwBOk">}</span> <span class="kt" id="mwBOo">void</span><span class="w" id="mwBOs"> </span><span class="nf" id="mwBOw">assign</span><span class="p" id="mwBO0">(</span><span class="kt" id="mwBO4">int</span><span class="o" id="mwBO8">*</span><span class="w" id="mwBPA"> </span><span class="n" id="mwBPE">p</span><span class="p" id="mwBPI">,</span><span class="w" id="mwBPM"> </span><span class="kt" id="mwBPQ">int</span><span class="w" id="mwBPU"> </span><span class="n" id="mwBPY">v</span><span class="p" id="mwBPc">)</span><span class="w" id="mwBPg"> </span><span class="p" id="mwBPk">{</span> <span class="w" id="mwBPo"> </span><span class="o" id="mwBPs">*</span><span class="n" id="mwBPw">p</span><span class="w" id="mwBP0"> </span><span class="o" id="mwBP4">=</span><span class="w" id="mwBP8"> </span><span class="n" id="mwBQA">v</span><span class="p" id="mwBQE">;</span> <span class="p" id="mwBQI">}</span> <span class="kt" id="mwBQM">void</span><span class="w" id="mwBQQ"> </span><span class="nf" id="mwBQU">swap</span><span class="p" id="mwBQY">(</span><span class="kt" id="mwBQc">int</span><span class="o" id="mwBQg">*</span><span class="w" id="mwBQk"> </span><span class="n" id="mwBQo">a</span><span class="p" id="mwBQs">,</span><span class="w" id="mwBQw"> </span><span class="kt" id="mwBQ0">int</span><span class="o" id="mwBQ4">*</span><span class="w" id="mwBQ8"> </span><span class="n" id="mwBRA">b</span><span class="p" id="mwBRE">)</span><span class="w" id="mwBRI"> </span><span class="p" id="mwBRM">{</span> <span class="w" id="mwBRQ"> </span><span class="kt" id="mwBRU">int</span><span class="w" id="mwBRY"> </span><span class="n" id="mwBRc">temp_storage</span><span class="p" id="mwBRg">;</span><span class="w" id="mwBRk"> </span> <span class="w" id="mwBRo"> </span><span class="kt" id="mwBRs">int</span><span class="o" id="mwBRw">*</span><span class="w" id="mwBR0"> </span><span class="n" id="mwBR4">temp</span><span class="w" id="mwBR8"> </span><span class="o" id="mwBSA">=</span><span class="w" id="mwBSE"> </span><span class="o" id="mwBSI">&</span><span class="n" id="mwBSM">temp_storage</span><span class="p" id="mwBSQ">;</span> <span class="w" id="mwBSU"> </span><span class="n" id="mwBSY">assign</span><span class="p" id="mwBSc">(</span><span class="n" id="mwBSg">temp</span><span class="p" id="mwBSk">,</span><span class="w" id="mwBSo"> </span><span class="n" id="mwBSs">read</span><span class="p" id="mwBSw">(</span><span class="n" id="mwBS0">a</span><span class="p" id="mwBS4">));</span> <span class="w" id="mwBS8"> </span><span class="n" id="mwBTA">assign</span><span class="p" id="mwBTE">(</span><span class="n" id="mwBTI">a</span><span class="p" id="mwBTM">,</span><span class="w" id="mwBTQ"> </span><span class="n" id="mwBTU">read</span><span class="p" id="mwBTY">(</span><span class="n" id="mwBTc">b</span><span class="p" id="mwBTg">));</span> <span class="w" id="mwBTk"> </span><span class="n" id="mwBTo">assign</span><span class="p" id="mwBTs">(</span><span class="n" id="mwBTw">b</span><span class="p" id="mwBT0">,</span><span class="w" id="mwBT4"> </span><span class="n" id="mwBT8">read</span><span class="p" id="mwBUA">(</span><span class="n" id="mwBUE">temp</span><span class="p" id="mwBUI">));</span> <span class="p" id="mwBUM">}</span> <span class="kt" id="mwBUQ">int</span><span class="w" id="mwBUU"> </span><span class="nf" id="mwBUY">main</span><span class="p" id="mwBUc">()</span><span class="w" id="mwBUg"> </span><span class="p" id="mwBUk">{</span> <span class="w" id="mwBUo"> </span><span class="kt" id="mwBUs">int</span><span class="w" id="mwBUw"> </span><span class="n" id="mwBU0">a_storage</span><span class="p" id="mwBU4">;</span><span class="w" id="mwBU8"> </span> <span class="w" id="mwBVA"> </span><span class="kt" id="mwBVE">int</span><span class="o" id="mwBVI">*</span><span class="w" id="mwBVM"> </span><span class="n" id="mwBVQ">a</span><span class="w" id="mwBVU"> </span><span class="o" id="mwBVY">=</span><span class="w" id="mwBVc"> </span><span class="o" id="mwBVg">&</span><span class="n" id="mwBVk">a_storage</span><span class="p" id="mwBVo">;</span> <span class="w" id="mwBVs"> </span><span class="kt" id="mwBVw">int</span><span class="w" id="mwBV0"> </span><span class="n" id="mwBV4">b_storage</span><span class="p" id="mwBV8">;</span><span class="w" id="mwBWA"> </span> <span class="w" id="mwBWE"> </span><span class="kt" id="mwBWI">int</span><span class="o" id="mwBWM">*</span><span class="w" id="mwBWQ"> </span><span class="n" id="mwBWU">b</span><span class="w" id="mwBWY"> </span><span class="o" id="mwBWc">=</span><span class="w" id="mwBWg"> </span><span class="o" id="mwBWk">&</span><span class="n" id="mwBWo">b_storage</span><span class="p" id="mwBWs">;</span> <span class="w" id="mwBWw"> </span><span class="n" id="mwBW0">assign</span><span class="p" id="mwBW4">(</span><span class="n" id="mwBW8">a</span><span class="p" id="mwBXA">,</span><span class="w" id="mwBXE"> </span><span class="mi" id="mwBXI">1</span><span class="p" id="mwBXM">);</span> <span class="w" id="mwBXQ"> </span><span class="n" id="mwBXU">assign</span><span class="p" id="mwBXY">(</span><span class="n" id="mwBXc">b</span><span class="p" id="mwBXg">,</span><span class="w" id="mwBXk"> </span><span class="mi" id="mwBXo">2</span><span class="p" id="mwBXs">);</span> <span class="w" id="mwBXw"> </span><span class="n" id="mwBX0">swap</span><span class="p" id="mwBX4">(</span><span class="n" id="mwBX8">a</span><span class="p" id="mwBYA">,</span><span class="w" id="mwBYE"> </span><span class="n" id="mwBYI">b</span><span class="p" id="mwBYM">);</span> <span class="w" id="mwBYQ"> </span><span class="n" id="mwBYU">printf</span><span class="p" id="mwBYY">(</span><span class="s" id="mwBYc">"%d %d</span><span class="se" id="mwBYg">\n</span><span class="s" id="mwBYk">"</span><span class="p" id="mwBYo">,</span><span class="w" id="mwBYs"> </span><span class="n" id="mwBYw">read</span><span class="p" id="mwBY0">(</span><span class="n" id="mwBY4">a</span><span class="p" id="mwBY8">),</span><span class="w" id="mwBZA"> </span><span class="n" id="mwBZE">read</span><span class="p" id="mwBZI">(</span><span class="n" id="mwBZM">b</span><span class="p" id="mwBZQ">));</span><span class="w" id="mwBZU"> </span><span class="c1" id="mwBZY">// 2 1</span> <span class="w" id="mwBZc"> </span><span class="k" id="mwBZg">return</span><span class="w" id="mwBZk"> </span><span class="mi" id="mwBZo">0</span><span class="p" id="mwBZs">;</span> <span class="p" id="mwBZw">}</span>Because in this program, swap operates on pointers and cannot change the pointers themselves, but only the values the pointers point to, this view holds that C's main evaluation strategy is more similar to call-by-sharing.
C++ confuses the issue further by allowing swap to be declared and used with a very lightweight "reference" syntax:
<span id="mwBac"></span><span class="kt" id="mwBag">void</span><span class="w" id="mwBak"> </span><span class="nf" id="mwBao">swap</span><span class="p" id="mwBas">(</span><span class="kt" id="mwBaw">int</span><span class="o" id="mwBa0">&</span><span class="w" id="mwBa4"> </span><span class="n" id="mwBa8">a</span><span class="p" id="mwBbA">,</span><span class="w" id="mwBbE"> </span><span class="kt" id="mwBbI">int</span><span class="o" id="mwBbM">&</span><span class="w" id="mwBbQ"> </span><span class="n" id="mwBbU">b</span><span class="p" id="mwBbY">)</span><span class="w" id="mwBbc"> </span><span class="p" id="mwBbg">{</span> <span class="w" id="mwBbk"> </span><span class="kt" id="mwBbo">int</span><span class="w" id="mwBbs"> </span><span class="n" id="mwBbw">temp</span><span class="w" id="mwBb0"> </span><span class="o" id="mwBb4">=</span><span class="w" id="mwBb8"> </span><span class="n" id="mwBcA">a</span><span class="p" id="mwBcE">;</span> <span class="w" id="mwBcI"> </span><span class="n" id="mwBcM">a</span><span class="w" id="mwBcQ"> </span><span class="o" id="mwBcU">=</span><span class="w" id="mwBcY"> </span><span class="n" id="mwBcc">b</span><span class="p" id="mwBcg">;</span> <span class="w" id="mwBck"> </span><span class="n" id="mwBco">b</span><span class="w" id="mwBcs"> </span><span class="o" id="mwBcw">=</span><span class="w" id="mwBc0"> </span><span class="n" id="mwBc4">temp</span><span class="p" id="mwBc8">;</span> <span class="p" id="mwBdA">}</span> <span class="kt" id="mwBdE">int</span><span class="w" id="mwBdI"> </span><span class="nf" id="mwBdM">main</span><span class="p" id="mwBdQ">()</span><span class="w" id="mwBdU"> </span><span class="p" id="mwBdY">{</span> <span class="w" id="mwBdc"> </span><span class="kt" id="mwBdg">int</span><span class="w" id="mwBdk"> </span><span class="n" id="mwBdo">a</span><span class="w" id="mwBds"> </span><span class="o" id="mwBdw">=</span><span class="w" id="mwBd0"> </span><span class="mi" id="mwBd4">1</span><span class="p" id="mwBd8">;</span> <span class="w" id="mwBeA"> </span><span class="kt" id="mwBeE">int</span><span class="w" id="mwBeI"> </span><span class="n" id="mwBeM">b</span><span class="w" id="mwBeQ"> </span><span class="o" id="mwBeU">=</span><span class="w" id="mwBeY"> </span><span class="mi" id="mwBec">2</span><span class="p" id="mwBeg">;</span> <span class="w" id="mwBek"> </span><span class="n" id="mwBeo">swap</span><span class="p" id="mwBes">(</span><span class="n" id="mwBew">a</span><span class="p" id="mwBe0">,</span><span class="w" id="mwBe4"> </span><span class="n" id="mwBe8">b</span><span class="p" id="mwBfA">);</span> <span class="w" id="mwBfE"> </span><span class="n" id="mwBfI">std</span><span class="o" id="mwBfM">::</span><span class="n" id="mwBfQ">println</span><span class="p" id="mwBfU">(</span><span class="s" id="mwBfY">"{} {}"</span><span class="p" id="mwBfc">,</span><span class="w" id="mwBfg"> </span><span class="n" id="mwBfk">a</span><span class="p" id="mwBfo">,</span><span class="w" id="mwBfs"> </span><span class="n" id="mwBfw">b</span><span class="p" id="mwBf0">);</span><span class="w" id="mwBf4"> </span><span class="c1" id="mwBf8">// 2 1</span> <span class="w" id="mwBgA"> </span><span class="k" id="mwBgE">return</span><span class="w" id="mwBgI"> </span><span class="mi" id="mwBgM">0</span><span class="p" id="mwBgQ">;</span> <span class="p" id="mwBgU">}</span>Semantically, this is equivalent to the C examples. As such, many authors consider call-by-address to be a unique parameter passing strategy distinct from call-by-value, call-by-reference, and call-by-sharing.
Call by unification
In logic programming, the evaluation of an expression may simply correspond to the unification of the terms involved combined with the application of some form of resolution. Unification must be classified as a strict binding strategy because it is fully performed. However, unification can also be performed on unbounded variables, so calls may not necessarily commit to final values for all its variables.
Non-strict binding strategies
Call by name
Call by name is an evaluation strategy where the arguments to a function are not evaluated before the function is called—rather, they are substituted directly into the function body (using capture-avoiding substitution) and then left to be evaluated whenever they appear in the function. If an argument is not used in the function body, the argument is never evaluated; if it is used several times, it is re-evaluated each time it appears. (See Jensen's device for a programming technique that exploits this.)
Call-by-name evaluation is occasionally preferable to call-by-value evaluation. If a function's argument is not used in the function, call by name will save time by not evaluating the argument, whereas call by value will evaluate it regardless. If the argument is a non-terminating computation, the advantage is enormous. However, when the function argument is used, call by name is often slower, requiring a mechanism such as a thunk.
.NET languages can simulate call by name using delegates or Expression<T> parameters. The latter results in an abstract syntax tree being given to the function. Eiffel provides agents, which represent an operation to be evaluated when needed. Java programs can accomplish similar lazy evaluation using lambda expressions and the java.util.function.Supplier<T> interface.
Call by need
Call by need is a memoized variant of call by name, where, if the function argument is evaluated, that value is stored for subsequent use. If the argument is pure (i.e., free of side effects), this produces the same results as call by name, saving the cost of recomputing the argument.
Haskell is a well-known language that uses call-by-need evaluation. Because evaluation of expressions may happen arbitrarily far into a computation, Haskell supports only side effects (such as mutation) via the use of monads. This eliminates any unexpected behavior from variables whose values change prior to their delayed evaluation.
In R's implementation of call by need, all arguments are passed, meaning that R allows arbitrary side effects.
Lazy evaluation is the most common implementation of call-by-need semantics, but variations like optimistic evaluation exist. .NET languages implement call by need using the type Lazy<T>.
Graph reduction is an efficient implementation of lazy evaluation.
Call by macro expansion
Call by macro expansion is similar to call by name, but uses textual substitution rather than capture-avoiding substitution. Macro substitution may therefore result in variable capture, leading to mistakes and undesired behavior. Hygienic macros avoid this problem by checking for and replacing shadowed variables that are not parameters.
Call by future
"Call by future", also known as "parallel call by name" or "lenient evaluation", is a concurrent evaluation strategy combining non-strict semantics with eager evaluation. The method requires fine-grained dynamic scheduling and synchronization but is suitable for massively parallel machines.
The strategy creates a future (promise) for the function's body and each of its arguments. These futures are computed concurrently with the flow of the rest of the program. When a future A requires the value of another future B that has not yet been computed, future A blocks until future B finishes computing and has a value. If future B has already finished computing the value is returned immediately. Conditionals block until their condition is evaluated, and lambdas do not create futures until they are fully applied.
If implemented with processes or threads, creating a future will spawn one or more new processes or threads (for the promises), accessing the value will synchronize these with the main thread, and terminating the computation of the future corresponds to killing the promises computing its value. If implemented with a coroutine, as in .NET async/await, creating a future calls a coroutine (an async function), which may yield to the caller, and in turn be yielded back to when the value is used, cooperatively multitasking.
The strategy is non-deterministic, as the evaluation can occur at any time between creation of the future (i.e., when the expression is given) and use of the future's value. The strategy is non-strict because the function body may return a value before the arguments are evaluated. However, in most implementations, execution may still get stuck evaluating an unneeded argument. For example, the program
<span id="mwBkg"></span><span class="nf" id="mwBkk">f</span><span class="w" id="mwBko"> </span><span class="n" id="mwBks">x</span><span class="w" id="mwBkw"> </span><span class="ow" id="mwBk0">=</span><span class="w" id="mwBk4"> </span><span class="mi" id="mwBk8">1</span><span class="o" id="mwBlA">/</span><span class="n" id="mwBlE">x</span> <span class="nf" id="mwBlI">g</span><span class="w" id="mwBlM"> </span><span class="n" id="mwBlQ">y</span><span class="w" id="mwBlU"> </span><span class="ow" id="mwBlY">=</span><span class="w" id="mwBlc"> </span><span class="mi" id="mwBlg">1</span> <span class="nf" id="mwBlk">main</span><span class="w" id="mwBlo"> </span><span class="ow" id="mwBls">=</span><span class="w" id="mwBlw"> </span><span class="n" id="mwBl0">print</span><span class="w" id="mwBl4"> </span><span class="p" id="mwBl8">(</span><span class="n" id="mwBmA">g</span><span class="w" id="mwBmE"> </span><span class="p" id="mwBmI">(</span><span class="n" id="mwBmM">f</span><span class="w" id="mwBmQ"> </span><span class="mi" id="mwBmU">0</span><span class="p" id="mwBmY">))</span>
may either have g finish before f, and output 1, or may result in an error due to evaluating 1/0.
Call-by-future is similar to call by need in that values are computed only once. With careful handling of errors and nontermination, in particular terminating futures partway through if it is determined they will not be needed, call-by-future also has the same termination properties as call-by-need evaluation. However, call-by-future may perform unnecessary speculative work compared to call-by-need, such as deeply evaluating a lazy data structure. This can be avoided by using lazy futures that do not start computation until it is certain the value is needed.
Optimistic evaluation
Optimistic evaluation is a call-by-need variant where the function's argument is partly evaluated in a call-by-value style for some amount of time (which may be adjusted at runtime). After that time has passed, evaluation is aborted and the function is applied using call by need. This approach avoids some of call-by-need's runtime expenses while retaining desired termination characteristics.