View source for Callback (computer programming)

{{Short description|A function provided as an argument to another function to be called during its execution}}
{{More references|date=September 2015}}
[[File:Callback-notitle.svg|thumb|370px|A callback is often back on the level of the original caller.]]

In [[Computer programming|computer programming]], a '''callback''' or '''callback function''' is any reference to executable code that is passed as an argument to another piece of code; that code is expected to ''call back'' (execute) the callback function as part of its job. This execution may be immediate as in a '''synchronous callback''', or it might happen at a later point in time as in an '''asynchronous callback'''. They are also called '''blocking''' and '''non-blocking'''.

Programming languages support callbacks in different ways, often implementing them with subroutines, lambda expressions, [[Block (programming)|blocks]], or function pointers.

== {{Anchor|TYPES}}Design ==
There are two types of callbacks, differing in how they control data flow at runtime: ''blocking callbacks'' (also known as ''synchronous callbacks'' or just ''callbacks'') and ''deferred callbacks'' (also known as ''asynchronous callbacks''). While blocking callbacks are invoked before a function returns (as in the C example below), deferred callbacks may be invoked after a function returns. Deferred callbacks are often used in the context of I/O operations or event handling, and are called by interrupts or by a different thread in case of multiple threads. Due to their nature, blocking callbacks can work without interrupts or multiple threads, meaning that blocking callbacks are not commonly used for synchronization or for delegating work to another thread.

Callbacks are used to program applications in windowing systems. In this case, the application supplies (a reference to) a specific custom callback function for the operating system to call, which then calls this application-specific function in response to events like mouse clicks or key presses. A major concern here is the management of privilege and security: while the function is called from the operating system, it should not run with the same privilege as the system. A solution to this problem is using rings of protection.

==Implementation==
The form of a callback varies among [[Programming language|programming language]]s:

* In [[Assembly language|assembly]], [[C (programming language)|C]], [[C++]], [[Pascal (programming language)|Pascal]], Modula2 and similar languages, a machine-level [[Function pointer|pointer]] to a function may be passed as an argument to another (internal or external) function. This is supported by most compilers and provides the advantage of using different languages together without special wrapper libraries or classes. One example may be the [[Software:Windows API|Windows API]] that is directly (more or less) accessible by many different languages, compilers and assemblers.
* C++ allows objects to provide their own implementation of the function call operation. The [[Standard Template Library]] accepts these objects (called ''[[Function object|functors]]''), as well as function pointers, as parameters to various polymorphic algorithms.
<!-- Please clarify before you put this back in: *Some systems have built-in programming languages to support extension and adaptation. These languages provide callbacks without the need for separate software development tools. -->
* Many [[Dynamic programming language|dynamic languages]], such as [[JavaScript]], [[Lua (programming language)|Lua]], [[Python (programming language)|Python]], [[Perl]]<ref>{{cite web |url=http://www.unix.org.ua/orelly/perl/cookbook/ch11_05.htm |title=Perl Cookbook - 11.4. Taking References to Functions|date=2 July 1999 |accessdate=2008-03-03}}</ref><ref>{{cite web |url=http://www.unix.org.ua/orelly/perl/advprog/ch04_02.htm |title=Advanced Perl Programming - 4.2 Using Subroutine References |date=2 July 1999 |accessdate=2008-03-03}}</ref> and [[Organization:PHP|PHP]], simply allow a function object to be passed through.
* [[List of CLI languages|CLI languages]] such as [[C Sharp (programming language)|C#]] and VB.NET provide a [[Type safety|type-safe]] encapsulating reference, a "[[Delegate (CLI)|delegate]]", to define well-typed [[Function pointer|function pointer]]s. These can be used as callbacks.
* Events and event handlers, as used in .NET languages, provide generalized syntax for callbacks.
* Functional languages generally support first-class functions, which can be passed as callbacks to other functions, stored as data or returned from functions.
* Some languages, such as Algol 68, Perl, Python, [[Ruby (programming language)|Ruby]], [[Smalltalk]], [[C++11]] and later, newer versions of C# and VB.NET as well as most functional languages, allow unnamed blocks of code (lambda expressions) to be supplied instead of references to functions defined elsewhere.
* In some languages, e.g. [[Scheme (programming language)|Scheme]], [[ML (programming language)|ML]], JavaScript, Perl, Python, Smalltalk, PHP (since 5.3.0),<ref>{{cite web |url=https://secure.php.net/manual/en/functions.anonymous.php |title=PHP Language Reference - Anonymous functions | accessdate=2011-06-08}}</ref> C++11 and later, Java (since 8),<ref>{{cite web |url=http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html|title=What's New in JDK 8|work=oracle.com}}</ref> and many others, such functions can be closures, i.e. they can access and modify variables locally defined in the context in which the function was defined. Note that Java cannot, however, modify the local variables in the enclosing scope.
* In [[Object-oriented programming|object-oriented programming]] languages without function-valued arguments, such as in [[Java (programming language)|Java]] before its 8 version, callbacks can be simulated by passing an instance of an abstract class or interface, of which the receiver will call one or more methods, while the calling end provides a concrete implementation. Such objects are effectively a bundle of callbacks, plus the data they need to manipulate{{Clarify|date=September 2014}}. They are useful in implementing various design patterns such as [[Visitor pattern|Visitor]], [[Observer pattern|Observer]], and [[Strategy pattern|Strategy]].
* In PL/I and [[ALGOL 60]] a callback procedure may need to be able to access local variables in containing blocks, so it is called through an ''entry variable'' containing both the entry point and context information. <ref>{{cite book |editor1-last=Belzer |editor1-first=Jack |editor2-last=Holzman |editor2-first=Albert G |editor3-last=Kent |editor3-first=Allen |title=Encyclopedia of Computer Science and Technology: Volume 12 |date=1979 |publisher=Marcel Dekker, inc. |isbn=0-8247-2262-0 |page=164 |url=https://books.google.com/books?id=IFmaqTI9-KsC&pg=PA164 |access-date=January 28, 2024}}</ref>

==Use==

=== Daily life analogy ===
A customer visited a store, but found the desired item to be out of stock. 

They leave their address and a check with a clerk, instructing the clerk to cash in the check and send the item to the address (registering a callback function). 

When the item became available, the clerk performs the instruction (calling the callback function). 

===C===
Callbacks have a wide variety of uses, for example in error signaling: a [[Software:Unix|Unix]] program might not want to terminate immediately when it receives SIGTERM, so to make sure that its termination is handled properly, it would register the cleanup function as a callback. Callbacks may also be used to control whether a function acts or not: [[Software:Xlib|Xlib]] allows custom predicates to be specified to determine whether a program wishes to handle an event.

The following [[C (programming language)|C]] code demonstrates the use of callbacks to display two numbers.

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* The calling function takes a single callback as a parameter. */
void PrintTwoNumbers(int (*numberSource)(void)) {
    int val1 = numberSource();
    int val2 = numberSource();
    printf("%d and %d\n", val1, val2);
}

/* A possible callback */
int overNineThousand(void) {
    return (rand()%1000) + 9001;
}

/* Another possible callback. */
int meaningOfLife(void) {
    return 42;
}

/* Here we call PrintTwoNumbers() with three different callbacks. */
int main(void) {
    time_t t;
    srand((unsigned)time(&t)); // Init seed for random function
    PrintTwoNumbers(&rand);
    PrintTwoNumbers(&overNineThousand);
    PrintTwoNumbers(&meaningOfLife);
    return 0;
}
</source>

Example output:

 {{Random number|32768}} and {{Random number|32768|{{Random number|32768}}}}
 {{#expr: {{Random number|1000}} + 9001}} and {{#expr: {{Random number|1000|{{Random number|1000}}}} + 9001}}
 42 and 42

Note how this is different from simply passing the output of the callback function to the calling function, PrintTwoNumbers() - rather than printing the same value twice, the PrintTwoNumbers calls the callback as many times as it requires. This is one of the two main advantages of callbacks.

The other advantage is that the calling function can pass whatever parameters it wishes to the called functions (not shown in the above example). This allows correct [[Information hiding|information hiding]]: the code that passes a callback to a calling function does not need to know the parameter values that will be passed to the function. If it only passed the return value, then the parameters would need to be exposed publicly.{{Examples|date=July 2012}}

Another example:

<source lang="c">
/*
 * This is a simple C program to demonstrate the usage of callbacks
 * The callback function is in the same file as the calling code.
 * The callback function can later be put into external library like
 * e.g. a shared object to increase flexibility.
 */

#include <stdio.h>
#include <string.h>

typedef struct _MyMsg {
    int appId;
    char msgbody[32];
} MyMsg;

void myfunc(MyMsg *msg)
{
    if (strlen(msg->msgbody) > 0 )
        printf("App Id = %d \nMsg = %s \n",msg->appId, msg->msgbody);
    else
        printf("App Id = %d \nMsg = No Msg\n",msg->appId);
}

/*
 * Prototype declaration
 */
void (*callback)(MyMsg *);

int main(void)
{
    MyMsg msg1;
    msg1.appId = 100;
    strcpy(msg1.msgbody, "This is a test\n");

    /*
     * Assign the address of the function "myfunc" to the function
     * pointer "callback" (may be also written as "callback = &myfunc;")
     */
    callback = myfunc;

    /*
     * Call the function (may be also written as "(*callback)(&msg1);")
     */
    callback(&msg1);

    return 0;
}
</source>

The output after compilation:

<source lang="console">
$ gcc cbtest.c
$ ./a.out
App Id = 100
Msg = This is a test
</source>

This information hiding means that callbacks can be used when communicating between processes or threads, or through serialised communications and tabular data. {{Clarify|date=August 2011}}

In C++, [[Function object|functor]] is also commonly used beside the usage of function pointer in C.

=== C# ===
A simple callback in [[C Sharp (programming language)|C#]]:
<source lang="c#">
public class Class1 
{
    static void Main(string[] args)
    {
        Class2 c2 = new Class2();
        
        /*
        * Calling method on Class2 with callback method as parameter
        */
        c2.Method(CallBackMethod);
    }

    /*
    * The callback method. This method prints the string sent in the callback
    */
    static void CallBackMethod(string str)
    {
        Console.WriteLine($"Callback was: {str}");
    }
}

public class Class2
{
    /*
    * The method that calls back to the caller. Takes an action (method) as parameter
    */
    public void Method(Action<string> callback)
    {
        /*
        * Calls back to method CallBackMet in Class1 with the message specified
        */
        callback("The message to send back");
    }
}
</source>

===Kotlin===
A simple callback in [[Kotlin (programming language)|Kotlin]]:
<source lang="kotlin">
fun main(){
    print("Enter text: ")
    val question = readLine()
    answer(question, ::meaningOfLife)
}

fun meaningOfLife(): Int{
    return 42
}

fun answer(question: String?, answer: () -> Int) {
    println("Your question: $question")
    println("Answer: ${answer()}")
}
</source>

===JavaScript===
Callbacks are used in the implementation of languages such as [[JavaScript]], including support of JavaScript functions as callbacks through js-ctypes<ref>{{cite web |url=https://developer.mozilla.org.cach3.com/en-US/docs/Mozilla/js-ctypes/Using_js-ctypes/Declaring_and_Using_Callbacks<!--This page is not properly rendered--> |title=Declaring and Using Callbacks |editor1-last=Holley |editor1-first=Bobby |editor2-last=Shepherd |editor2-first=Eric |department=Docs |website=Mozilla Developer Network |language=en |type=Documentation page |accessdate=2021-12-16 |url-status=live |archive-url=https://web.archive.org/web/20190117092921/https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/Using_js-ctypes/Declaring_and_Using_Callbacks |archive-date=2019-01-17}}</ref> and in components such as {{notatypo|addEventListener}}.<ref>{{cite web |url=https://udn.realityripple.com/docs/Mozilla/Creating_JavaScript_callbacks_in_components#JavaScript_functions_as_callbacks |title=Creating JavaScript callbacks in components |department=Archive |website=UDN Web Docs |at=sec. JavaScript functions as callbacks |language=en |type=Documentation page |accessdate=2021-12-16 |url-status=live|archive-url=https://web.archive.org/web/20211216020616/https://udn.realityripple.com/docs/Mozilla/Creating_JavaScript_callbacks_in_components |archive-date=2021-12-16 }}</ref> However, a native example of a callback can be written without any complex code:

<source lang="javascript">
function calculate(num1, num2, callbackFunction) {
    return callbackFunction(num1, num2);
}

function calcProduct(num1, num2) {
    return num1 * num2;
}

function calcSum(num1, num2) {
    return num1 + num2;
}
// alerts 150, the product of 5 and 15
alert(calculate(10, 15, calcProduct));
// alerts 20, the sum of 5 and 15
alert(calculate(5, 15, calcSum));
</source>

First a function {{Mono|calculate}} is defined with a parameter intended for callback: {{Mono|callbackFunction}}. Then a function that can be used as a callback to {{Mono|calculate}} is defined, {{Mono|calcProduct}}. Other functions may be used for {{Mono|callbackFunction}}, like {{Mono|calcSum}}. In this example, {{Mono|calculate()}} is invoked twice, once with {{Mono|calcProduct}} as a callback and once with {{Mono|calcSum}}. The functions return the product and sum, respectively, and then the alert will display them to the screen.

In this primitive example, the use of a callback is primarily a demonstration of principle. One could simply call the callbacks as regular functions, {{Mono|calcProduct(num1, num2)}}. Callbacks are generally used when the function needs to perform events before the callback is executed, or when the function does not (or cannot) have meaningful return values to act on, as is the case for [[Ajax (programming)|Asynchronous JavaScript]] (based on timers) or [[XMLHttpRequest]] requests. Useful examples can be found in JavaScript libraries such as [[Software:JQuery|jQuery]] where the {{notatypo|.each()}} method iterates over an array-like object, the first argument being a callback that is performed on each iteration.

===Red and REBOL===

From the [[JavaScript]] above, here is how one would implement the same in either REBOL or [[Red (programming language)]]. Notice the cleaner presentation of data as code.

* return is implied as the code in each function is the last line of the block
* As alert requires a string, form produces a string from the result of calculate
* The get-word! values (i.e., :calc-product and :calc-sum) trigger the interpreter to return the code of the function rather than evaluate with the function.
* The datatype! references in a block! [float! integer!] restrict the type of values passed as arguments.

<source lang="red">
Red [Title: "Callback example"]

calculate: func [
    num1 [number!] 
    num2 [number!] 
    callback-function [function!]
][
    callback-function num1 num2
]

calc-product: func [
    num1 [number!] 
    num2 [number!]
][
    num1 * num2
]

calc-sum: func [
    num1 [number!] 
    num2 [number!]
][
    num1 + num2
]

; alerts 75, the product of 5 and 15
alert form calculate 5 15 :calc-product

; alerts 20, the sum of 5 and 15
alert form calculate 5 15 :calc-sum
</source>

===Lua===
A color tweening example using the [[Software:Roblox|Roblox]] engine that takes an optional {{notatypo|.done}} callback:

<source lang="lua">
wait(1)
local DT = wait()

function tween_color(object, finish_color, fade_time)
  local step_r = finish_color.r - object.BackgroundColor3.r
  local step_g = finish_color.g - object.BackgroundColor3.g
  local step_b = finish_color.b - object.BackgroundColor3.b
  local total_steps = 1/(DT*(1/fade_time))
  local completed;
  coroutine.wrap(function()
    for i = 0, 1, DT*(1 / fade_time) do
      object.BackgroundColor3 = Color3.new (
        object.BackgroundColor3.r + (step_r/total_steps),
        object.BackgroundColor3.g + (step_g/total_steps),
        object.BackgroundColor3.b + (step_b/total_steps)
      )
      wait()
    end
    if completed then
      completed()
    end
  end)()
  return {
    done = function(callback)
      completed = callback
    end
  }
end

tween_color(some_object, Color3.new(1, 0, 0), 1).done(function()
  print "Color tweening finished!"
end)
</source>

===Python===
A typical use of callbacks in Python (and other languages) is to assign events to UI elements.

Here is a very trivial example of the use of a callback in Python. First define two functions, the callback and the calling code,
then pass the callback function into the calling code.

<source lang="pycon">
>>> def get_square(val):
...     """The callback."""
...     return val ** 2
...
>>> def caller(func, val):
...     return func(val)
...
>>> caller(get_square, 5)
25
</source>

===Julia===

Functions in [[Julia (programming language)|Julia]] are [[First-class citizen|first-class citizen]], so they can simply be passed to higher-level functions to be used (called) within the body of that functions.

Here the same example above in Julia:

<source lang="jlcon">
julia> get_square(val)  = val^2 # The callback
get_square (generic function with 1 method)
julia> caller(func,val) = func(val)
caller (generic function with 1 method)
julia> caller(get_square,5)
25

</source>

==See also==

{{Div col|colwidth=25em}}
* [[Command pattern]]
* [[Continuation-passing style]]
* [[Event loop]]
* [[Event-driven programming]]
* [[Implicit invocation]]
* [[Inversion of control]]
* [[Software:Libsigc++|libsigc++]], a callback library for C++
* [[Software:Signals and slots|Signals and slots]]
* [[User exit]]
{{div col end}}

== References ==
{{reflist}}

== External links ==
* [https://web.archive.org/web/20071009224137/http://msdn.microsoft.com/msdnmag/issues/02/12/BasicInstincts/ Basic Instincts: Implementing Callback Notifications Using Delegates]
* [https://web.archive.org/web/20080916192721/http://www.javaworld.com/javaworld/javatips/jw-javatip10.html Implement callback routines in Java]
* [https://web.archive.org/web/20041111063702/http://www.codeproject.com/aspnet/ScriptCallbackFramework.asp Implement Script Callback Framework in ASP.NET]
* [https://web.archive.org/web/20110706132209/http://www.comp.ua.ac.be/publications/files/Adapter-Para04.pdf Interfacing C++ member functions with C libraries] (archived from the original on July 6, 2011)
* [http://gotw.ca/gotw/083.htm Style Case Study #2: Generic Callbacks]

[[Category:Subroutines]]

{{Sourceattribution|Callback (computer programming)}}