In
computer science
Computer science is the study of computation, automation, and information. Computer science spans theoretical disciplines (such as algorithms, theory of computation, information theory, and automation) to practical disciplines (includin ...
, a type signature or type annotation defines the inputs and outputs for a function,
subroutine
In computer programming, a function or subroutine is a sequence of program instructions that performs a specific task, packaged as a unit. This unit can then be used in programs wherever that particular task should be performed.
Functions ma ...
or
method. A type signature includes the number, types, and order of the arguments contained by a function. A type signature is typically used during
overload resolution for choosing the correct definition of a function to be called among many overloaded forms.
Examples
C/C++
In
C and
C++, the type signature is
declared
In the sport of cricket, a declaration occurs when a captain declares his team's innings closed and a forfeiture occurs when a captain chooses to forfeit an innings without batting. Declaration and forfeiture are covered in Law 15 of the ''Laws of ...
by what is commonly known as a
function prototype. In C/C++, a function
declaration reflects its use; for example, a
function pointer
A function pointer, also called a subroutine pointer or procedure pointer, is a pointer that points to a function. As opposed to referencing a data value, a function pointer points to executable code within memory. Dereferencing the function point ...
with the signature would be called as:
char c;
double d;
int retVal = (*fPtr)(c, d);
Erlang
In
Erlang, type signatures may be optionally declared, as:
-spec(function_name(type1(), type2(), ...) -> out_type()).
For example:
-spec(is_even(number()) -> boolean()).
Haskell
A type signature in
Haskell generally takes the following form:
functionName :: arg1Type -> arg2Type -> ... -> argNType
Notice that the type of the result can be regarded as everything past the first supplied argument. This is a consequence of
currying, which is made possible by Haskell's support for
first-class functions; this function requires two inputs where one argument supplied and the function is "curried" to produce a function for the argument not supplied. Thus calling , where , yields a new function that can be called to produce .
The actual type specifications can consist of an actual type, such as , or a general
type variable that is used in
parametric polymorphic functions, such as , or , or . So we can write something like:
Since Haskell supports
higher-order functions, functions can be passed as arguments. This is written as:
This function takes in a function with type signature and returns data of type out.
Java
In the
Java virtual machine, ''internal type signatures'' are used to identify methods and classes at the level of the virtual machine code.
Example: The method is represented in
bytecode
Bytecode (also called portable code or p-code) is a form of instruction set designed for efficient execution by a software interpreter. Unlike human-readable source code, bytecodes are compact numeric codes, constants, and references (norma ...
as .
The signature of the method looks like this:
public static void main(String[] args);
And in the disassembled bytecode, it takes the form of
The method signature for the method contains three modifiers:
* indicates that the method can be called by any object.
* indicates that the method is a class method.
* indicates that the method has no return value.
Signature
A function signature consists of the function prototype. It specifies the general information about a function like the name, scope and parameters. Many programming languages use
name mangling in order to pass along more semantic information from the compilers to the linkers. In addition to mangling, there is an excess of information in a function signature (stored internally to most compilers) which is not readily available, but may be accessed.
Understanding the notion of a function signature is an important concept for all computer science studies.
* Modern object orientation techniques make use of
interfaces, which are essentially templates made from function signatures.
* C++ uses
function overloading with various signatures.
The practice of
multiple inheritance requires consideration of the function signatures to avoid unpredictable results.
Computer science theory, and the concept of
polymorphism
Polymorphism, polymorphic, polymorph, polymorphous, or polymorphy may refer to:
Computing
* Polymorphism (computer science), the ability in programming to present the same programming interface for differing underlying forms
* Ad hoc polymorphis ...
in particular, make much use of the concept of function signature.
In the C programming language signature is roughly equivalent to its
prototype definition.
The term "signature" may carry other meanings in computer science:
*
File signatures can identify or verify the content of a file.
* Database signatures can identify or verify the schema or a version of a database.
* In the
ML family of
programming language
A programming language is a system of notation for writing computer programs. Most programming languages are text-based formal languages, but they may also be graphical. They are a kind of computer language.
The description of a programming l ...
s, "signature" is used as a keyword referring to a construct of the module system that plays the role of an
interface.
Method signature
In
computer programming
Computer programming is the process of performing a particular computation (or more generally, accomplishing a specific computing result), usually by designing and building an executable computer program. Programming involves tasks such as anal ...
, especially
object-oriented programming
Object-oriented programming (OOP) is a programming paradigm based on the concept of " objects", which can contain data and code. The data is in the form of fields (often known as attributes or ''properties''), and the code is in the form of ...
, a
method is commonly identified by its unique method signature, which usually includes the method name, and the number, types and order of its
parameters. A method signature is the smallest
type
Type may refer to:
Science and technology Computing
* Typing, producing text via a keyboard, typewriter, etc.
* Data type, collection of values used for computations.
* File type
* TYPE (DOS command), a command to display contents of a file.
* Ty ...
of a method.
Examples
C/C++
In C/C++, the method signature is the method name and the number and type of its parameters, but it is possible to have a last parameter that consists of an array of values:
int printf(const char*, ... );
Manipulation of these parameters can be done by using the routines in the standard library header .
C#
Similar to the syntax of C, method signatures in
C# are composed of a name and the number and type of its parameters, where the last parameter may be an array of values:
void Add(out int sum, params int[] value);
[...]
Add(out sum, 3, 5, 7, 11, -1); // sum 25
Java
In Java (programming language), Java, a method signature is composed of a name and the number, type and order of its parameters. Return types and thrown exceptions are not considered to be a part of the method signature, nor are the names of parameters; they are ignored by the compiler for checking method uniqueness.
The method signatures help distinguish overloaded methods (methods with the same name) in a class. Return types are not included in overloading. Only method signatures should be used to distinguish overloaded methods.
For example, the following two methods have different signatures:
void doSomething(String[] x); // doSomething(String[])
void doSomething(String x); // doSomething(String)
The following two methods both have the same signature:
int doSomething(int x); // doSomething(int)
void doSomething(int y) throws Exception; // doSomething(int)
Julia
In
Julia, function signatures take the following form:
commission(sale::Int, rate::Float64)::Float64
The types in the arguments are used for the
multiple dispatch. The return type is validated when the function returns a value, and a runtime exception is raised if the type of the value does not agree with the specified type.
Abstract types are allowed and is encouraged for implementing general behavior that is common to all subtypes. The above function can therefore be rewritten as follows. In this case, the function can accept any Integer and Real subtypes accordingly.
commission(sale::Integer, rate::Real)::Real
Types are completely optional in function arguments. When unspecified, it is equivalent to using the type Any, which is the super-type of all types. It is idiomatic to specify argument types but not return type.
Objective-C
In the
Objective-C
Objective-C is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. Originally developed by Brad Cox and Tom Love in the early 1980s, it was selected by NeXT for its N ...
programming language, method signatures for an object are declared in the interface header file. For example,
- (id)initWithInt:(int)value;
defines a method that returns a general object (an ) and takes one integer argument. Objective-C only requires a type in a signature to be explicit when the type is not ; this signature is equivalent:
- initWithInt:(int)value;
Rust
In
Rust, function signatures take the following form:
fn commission(sale: u32, rate: f64) -> f64;
See also
*
*
References
{{DEFAULTSORT:Type Signature
Type theory
Subroutines