Evaluation strategy

 ( Articles With Example Python Code ) 

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.

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:

program Main

   implicit none
   integer :: a = 1
   integer :: b = 2
   call Swap(a, b)
   print *, a, b ! 2 1
     

   subroutine Swap(a, b)
       integer, intent(inout) :: a, b
       integer :: temp
       temp = a
       a = b
       b = temp
   end subroutine Swap
     

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:

public class Main {

   static class Box {
       int value;
       public Box(int value) {
           this.value = value;
       }
   }
     

   static void swap(Box a, Box b) {
       int temp = a.value;
       a.value = b.value;
       b.value = temp;
   }
     

   public static void main(String[] args) {
       Box a = new Box(1);
       Box b = new Box(2);
       swap(a, b);
       System.out.printf("a = %d, b = %d%n", a.value, b.value);
       // output: a = 2, b = 1
   }
     

where an explicit Box type must be used to introduce a handle. Java is call-by-sharing but not call-by-reference.

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 or parameter occurs in an arbitrary order. From the following program (illegal in Ada 2012)

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 , 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 output parameter: 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: def f(l: listint) -> None:

   l.append(1)
     

m: listint = f(m) print(m) 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 : def f(l: listint) -> None:

   l = l + [1]
   print(l) # [1]
     

m: listint = f(m) print(m) #

1. include

void swap(int* a, int* b) {

   int temp = *a;
   *a = *b;
   *b = temp;
     

int main() {

   int a = 1;
   int b = 2;
   swap(&a, &b);
   printf("%d %d\n", a, b); // 2 1
   return 0;
     

Some authors treat & as part of the syntax of calling . Under this view, C supports the call-by-reference parameter passing strategy.