**Description**

The basic function object concepts are Generator,
Unary Function,
and Binary Function:
these describe, respectively, objects that
can be called as **f()**, **f(x)**, and **f(x,y)**. (This list could obviously
be extended to *ternary function* and beyond, but, in practice,
no STL algorithms require function objects of more than two
arguments.) All other function object concepts defined by the
STL are refinements of these three.

Function objects that return `bool` are an important
special case.
A Unary Function whose return type
is bool is called a Predicate,
and a Binary Function whose return
type is `bool` is called
a Binary Predicate.

There is an important distinction, but a somewhat subtle one,
between function objects and adaptable function objects. In
general, a function object has restrictions on the type of its
argument. The type restrictions need not be simple, though:
operator() may be overloaded, or may be a member template,
or both. Similarly, there need be no way for a program to
determine what those restrictions are. An adaptable function
object, however, does specify what the argument and return types
are, and provides nested typedefs so that those types can be
named and used in programs. If a type `F0` is a model of
Adaptable Generator,
then it must define `F0::result_type`.
Similarly, if `F1` is a model of
Adaptable Unary Function then
it must define `F1::argument_type` and
`F1::result_type`, and if
`F2` is a model of
Adaptable Binary Function then
it must define
`F2::first_argument_type`, `F2::second_argument_type`,
and
`F2::result_type`. The STL provides base classes
unary_function
and binary_function to simplify the definition of
Adaptable
Unary Functions and
Adaptable Binary Functions.

Adaptable function objects are important because they can be used by function object adaptors: function objects that transform or manipulate other function objects. The STL provides many different function object adaptors, including unary_negate (which returns the logical complement of the value returned by a particular AdaptablePredicate), and unary_compose and binary_compose, which perform composition of function object.

Finally, the STL includes many different predefined function
objects, including **arithmetic** operations (*plus, minus, multiplies,
divides, modulus*, and *negate*), **comparisons**
(*equal_to, not_equal_to
greater, less, greater_equal*, and *less_equal*), and **logical**
operations (*logical_and, logical_or*, and *logical_not*). It is
possible to perform very sophisticated operations without
actually writing a new function object, simply by combining
predefined function objects and function object adaptors.

webmaster@sgi.com