In
computer science
Computer science is the study of computation, information, and automation. Computer science spans Theoretical computer science, theoretical disciplines (such as algorithms, theory of computation, and information theory) to Applied science, ...
, a type signature or type annotation defines the inputs and outputs of a
function,
subroutine
In computer programming, a function (also procedure, method, subroutine, routine, or subprogram) is a callable unit of software logic that has a well-defined interface and behavior and can be invoked multiple times.
Callable units provide a ...
or
method
Method (, methodos, from μετά/meta "in pursuit or quest of" + ὁδός/hodos "a method, system; a way or manner" of doing, saying, etc.), literally means a pursuit of knowledge, investigation, mode of prosecuting such inquiry, or system. In re ...
. A type signature includes the number,
types, and order of the function's
arguments
An argument is a series of sentences, statements, or propositions some of which are called premises and one is the conclusion. The purpose of an argument is to give reasons for one's conclusion via justification, explanation, and/or persua ...
. One important use of a type signature is for function
overload resolution, where one particular definition of a function to be called is selected among many overloaded forms.
Examples
C/C++
In
C and
C++, the type signature is
declared by what is commonly known as a
function prototype
In computer programming, a function prototype is a declaration of a function that specifies the function's name and type signature (arity, data types of parameters, and return type), but omits the function body. While a function definition ...
. 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 referencing executable code, rather than data. Dereferencing the function pointer yields the referenced function, which can be invoked and passed arguments ...
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
Haskell () is a general-purpose, statically typed, purely functional programming language with type inference and lazy evaluation. Designed for teaching, research, and industrial applications, Haskell pioneered several programming language ...
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
In mathematics and computer science, currying is the technique of translating a function that takes multiple arguments into a sequence of families of functions, each taking a single argument.
In the prototypical example, one begins with a functi ...
, which is made possible by Haskell's support for
first-class function
In computer science, a programming language is said to have first-class functions if it treats function (programming), functions as first-class citizens. This means the language supports passing functions as arguments to other functions, returning ...
s; this function requires two inputs where one argument is 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
In type theory and programming languages, a type variable is a mathematical variable ranging over types. Even in programming languages that allow mutable variables, a type variable remains an abstraction, in the sense that it does not correspond ...
that is used in
parametric polymorphic functions, such as , or , or . So we can write something like:
Since Haskell supports
higher-order function In mathematics and computer science, a higher-order function (HOF) is a function that does at least one of the following:
* takes one or more functions as arguments (i.e. a procedural parameter, which is a parameter of a procedure that is itself ...
s, 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
A Java virtual machine (JVM) is a virtual machine that enables a computer to run Java programs as well as programs written in other languages that are also compiled to Java bytecode. The JVM is detailed by a specification that formally descr ...
, ''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 (normal ...
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
A programming language is a system of notation for writing computer programs.
Programming languages are described in terms of their syntax (form) and semantics (meaning), usually defined by a formal language. Languages usually provide features ...
use
name mangling
In compiler construction, name mangling (also called name decoration) is a technique used to solve various problems caused by the need to resolve unique names for programming entities in many modern programming languages.
It provides means to e ...
in order to pass along more semantic information from the
compiler
In computing, a compiler is a computer program that Translator (computing), translates computer code written in one programming language (the ''source'' language) into another language (the ''target'' language). The name "compiler" is primaril ...
s 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
Interface or interfacing may refer to:
Academic journals
* ''Interface'' (journal), by the Electrochemical Society
* '' Interface, Journal of Applied Linguistics'', now merged with ''ITL International Journal of Applied Linguistics''
* '' Inter ...
, which are essentially templates made from function signatures.
*
C++ uses
function overloading with various signatures.
The practice of
multiple inheritance
Multiple inheritance is a feature of some object-oriented computer programming languages in which an object or class can inherit features from more than one parent object or parent class. It is distinct from single inheritance, where an object ...
requires consideration of the function signatures to avoid unpredictable results. Computer science theory, and the concept of
polymorphism in particular, make much use of the concept of function signature.
In the
C programming language
C (''pronounced'' '' – like the letter c'') is a general-purpose programming language. It was created in the 1970s by Dennis Ritchie and remains very widely used and influential. By design, C's features cleanly reflect the capabilities of ...
, a signature is roughly equivalent to its
prototype definition.
In the
ML family of
programming language
A programming language is a system of notation for writing computer programs.
Programming languages are described in terms of their Syntax (programming languages), syntax (form) and semantics (computer science), semantics (meaning), usually def ...
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 or coding is the composition of sequences of instructions, called computer program, programs, that computers can follow to perform tasks. It involves designing and implementing algorithms, step-by-step specifications of proc ...
, especially
object-oriented programming
Object-oriented programming (OOP) is a programming paradigm based on the concept of '' objects''. Objects can contain data (called fields, attributes or properties) and have actions they can perform (called procedures or methods and impl ...
, a
method
Method (, methodos, from μετά/meta "in pursuit or quest of" + ὁδός/hodos "a method, system; a way or manner" of doing, saying, etc.), literally means a pursuit of knowledge, investigation, mode of prosecuting such inquiry, or system. In re ...
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 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 .
In C++, the return type can also follow the parameter list, which is referred to as a
trailing return type. The difference is only syntactic; in either case, the resulting signature is identical:
auto printf(const char*... ) -> int;
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
Multiple dispatch or multimethods is a feature of some programming languages in which a Subroutine, function or Method (computer programming), method can be dynamic dispatch, dynamically dispatched based on the run time (program lifecycle phase), ...
. 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 are 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 high-level general-purpose, object-oriented programming language that adds Smalltalk-style message passing (messaging) to the C programming language. Originally developed by Brad Cox and Tom Love in the early 1980s, it was ...
programming language, method signatures for an object are declared in the interface
header file
An include directive instructs a text file processor to replace the directive text with the content of a specified file.
The act of including may be logical in nature. The processor may simply process the include file content at the location of ...
. 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
Rust is an iron oxide, a usually reddish-brown oxide formed by the reaction of iron and oxygen in the catalytic presence of water or air moisture. Rust consists of hydrous iron(III) oxides (Fe2O3·nH2O) and iron(III) oxide-hydroxide (FeO(OH) ...
, function signatures take the following form:
fn commission(sale: u32, rate: f64) -> f64;
See also
*
References
{{DEFAULTSORT:Type Signature
Type theory
Subroutines