Callable object

See also: Function object

A callable object, in computer programming, is any object that can be called like a function.

In different languages

In C++

• pointer to function;
• pointer to member function;
• functor;
• lambda expression.
• std::function is a template class that can hold any callable object that matches its signature.

In C++, any class that overloads the function call operator operator() may be called using function-call syntax.

import std;

struct Foo {
    void operator()() const {
        std::println("Called.");
    }
};

int main() {
   Foo instance;
   instance(); // This will output "Called." to the screen.
}

In C#

• delegate;
• lambda expression.

In PHP

PHP 5.3+ has first-class functions that can be used e.g. as parameter to the usort() function:

$a = array(3, 1, 4);
usort($a, function ($x, $y) { return $x - $y; });

It is also possible in PHP 5.3+ to make objects invokable by adding a magic __invoke() method to their class:

class Minus
{
    public function __invoke($x, $y) { return $x - $y; }
}

$a = array(3, 1, 4);
usort($a, new Minus());

In Python

In Python, any object with a __call__() method (as well as all functions, classes, and methods) can be called using function-call syntax. The built-in callable function can approximately detect whether a given object is callable or not.

class Foo:
    def __call__(self) -> None:
        print("Called.")

class Bar:
    ...

instance: Foo = Foo()
instance()  # Outputs "Called." to the screen

assert(callable(instance)) # True since instance has __call__
assert(callable(zip)) # True since zip is a function, despite not having __call__
assert(callable(Bar)) # True since Bar is a class, despite not having __call__
assert(callable(lambda x: x)) # True since lambdas have __call__

A collections.abc.Callable type annotation can be used to declare that a given variable must be callable. A Callable[P, R], where P is a list of types and R is a type, can be called with values matching P as arguments and returns a value of type R. Other values for P, such as a ParamSpec or ..., denote more flexible cases.

def spam(ham: int, eggs: str) -> None:
    return None

func: Callable[[int, str], None] = spam
none: None = func(0, "foo")

In Dart

Callable objects are defined in Dart using the call() method.

class WannabeFunction {
  call(String a, String b, String c) => '$a $b $c!';
}

main() {
  var wf = new WannabeFunction();
  var out = wf("Hi","there,","gang");
  print('$out');
}

In Swift

In Swift, callable objects are defined using callAsFunction.

struct CallableStruct {
    var value: Int
    func callAsFunction(_ number: Int, scale: Int) {
        print(scale * (number + value))
    }
}
let callable = CallableStruct(value: 100)
callable(4, scale: 2)
callable.callAsFunction(4, scale: 2)
// Both function calls print 208.

External links

• C++ Callable concept