Type signature
Defines the inputs and outputs for a function, subroutine or method
- 8 min read
- 3 chapters
Related on Lably
Through Computer science, Function (computer programming) and Method (computer programming)
Examples
C/C++
In C and C++, the type signature is declared by what is commonly known as a function prototype. In C/C++, a function declaration reflects its use; for example, a function pointer with the signature (int)(char, double) would be called as:
<span id="mwJw"></span><span class="kt" id="mwKA">char</span><span class="w" id="mwKQ"> </span><span class="n" id="mwKg">c</span><span class="p" id="mwKw">;</span> <span class="kt" id="mwLA">double</span><span class="w" id="mwLQ"> </span><span class="n" id="mwLg">d</span><span class="p" id="mwLw">;</span> <span class="kt" id="mwMA">int</span><span class="w" id="mwMQ"> </span><span class="n" id="mwMg">retVal</span><span class="w" id="mwMw"> </span><span class="o" id="mwNA">=</span><span class="w" id="mwNQ"> </span><span class="p" id="mwNg">(</span><span class="o" id="mwNw">*</span><span class="n" id="mwOA">fPtr</span><span class="p" id="mwOQ">)(</span><span class="n" id="mwOg">c</span><span class="p" id="mwOw">,</span><span class="w" id="mwPA"> </span><span class="n" id="mwPQ">d</span><span class="p" id="mwPg">);</span>
Erlang
In Erlang, type signatures may be optionally declared, as:
<span id="mwSA"></span><span class="p" id="mwSQ">-</span><span class="ni" id="mwSg">spec</span><span class="w" id="mwSw"> </span><span class="n" id="mwTA">function_name</span><span class="p" id="mwTQ">(</span><span class="n" id="mwTg">type1</span><span class="p" id="mwTw">(),</span><span class="w" id="mwUA"> </span><span class="n" id="mwUQ">type2</span><span class="p" id="mwUg">(),</span><span class="w" id="mwUw"> </span><span class="p" id="mwVA">...)</span><span class="w" id="mwVQ"> </span><span class="o" id="mwVg">-></span><span class="w" id="mwVw"> </span><span class="n" id="mwWA">out_type</span><span class="p" id="mwWQ">().</span>
For example:
<span id="mwXQ"></span><span class="p" id="mwXg">-</span><span class="ni" id="mwXw">spec</span><span class="w" id="mwYA"> </span><span class="n" id="mwYQ">is_even</span><span class="p" id="mwYg">(</span><span class="n" id="mwYw">number</span><span class="p" id="mwZA">())</span><span class="w" id="mwZQ"> </span><span class="o" id="mwZg">-></span><span class="w" id="mwZw"> </span><span class="n" id="mwaA">boolean</span><span class="p" id="mwaQ">().</span>
Haskell
A type signature in Haskell generally takes the following form:
<span id="mwbw"></span><span class="nf" id="mwcA">functionName</span><span class="w" id="mwcQ"> </span><span class="ow" id="mwcg">::</span><span class="w" id="mwcw"> </span><span class="n" id="mwdA">arg1Type</span><span class="w" id="mwdQ"> </span><span class="ow" id="mwdg">-></span><span class="w" id="mwdw"> </span><span class="n" id="mweA">arg2Type</span><span class="w" id="mweQ"> </span><span class="ow" id="mweg">-></span><span class="w" id="mwew"> </span><span class="o" id="mwfA">...</span><span class="w" id="mwfQ"> </span><span class="ow" id="mwfg">-></span><span class="w" id="mwfw"> </span><span class="n" id="mwgA">argNType</span>
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 is supplied and the function is "curried" to produce a function for the argument not supplied. Thus, calling f x, where f :: a -> b -> c, yields a new function f2 :: b -> c that can be called f2 y to produce c.
The actual type specifications can consist of an actual type, such as Integer, or a general type variable that is used in parametric polymorphic functions, such as a, or b, or anyType. So we can write something like: functionName :: a -> a -> ... -> a
Since Haskell supports higher-order functions, functions can be passed as arguments. This is written as: functionName :: (a -> a) -> a
This function takes in a function with type signature a -> a and returns data of type a 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 String String.substring(int, int) is represented in bytecode as Ljava/lang/String.substring(II)Ljava/lang/String; .
The signature of the main method looks like this:
<span id="mwARk"></span><span class="kd" id="mwARo">public</span><span class="w" id="mwARs"> </span><span class="kd" id="mwARw">static</span><span class="w" id="mwAR0"> </span><span class="kt" id="mwAR4">void</span><span class="w" id="mwAR8"> </span><span class="nf" id="mwASA">main</span><span class="p" id="mwASE">(</span><span class="n" id="mwASI">String</span><span class="o" id="mwASM">[]</span><span class="w" id="mwASQ"> </span><span class="n" id="mwASU">args</span><span class="p" id="mwASY">);</span>
And in the disassembled bytecode, it takes the form of Lsome/package/Main/main:([Ljava/lang/String;)V
The method signature for the main() method contains three modifiers:
publicindicates that themain()method can be called by any object.staticindicates that themain()method is a class method.voidindicates that themain()method has no return value.
Sign in to keep reading
2 more chapters are free with a Lably account.
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 in particular, make much use of the concept of function signature.
In the C programming language, a signature is roughly equivalent to its prototype definition.
In the ML family of programming languages, "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, especially object-oriented programming, 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 of a method.
Examples
C
In C, the method signature is the method name and the number and type of its parameters, but it is possible to have variadic parameters, but these are not type-safe.
<span id="mwAYU"></span><span class="kt" id="mwAYY">int</span><span class="w" id="mwAYc"> </span><span class="nf" id="mwAYg">printf</span><span class="p" id="mwAYk">(</span><span class="k" id="mwAYo">const</span><span class="w" id="mwAYs"> </span><span class="kt" id="mwAYw">char</span><span class="o" id="mwAY0">*</span><span class="w" id="mwAY4"> </span><span class="n" id="mwAY8">fmt</span><span class="p" id="mwAZA">,</span><span class="w" id="mwAZE"> </span><span class="p" id="mwAZI">...);</span>
Manipulation of these parameters can be done by using the routines in the standard library header <stdarg.h>.
C++
In C++, in addition to the C-style function return type appearing before, the return type may 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.
If using variadic templates:
<span id="mwAZw"></span><span class="kt" id="mwAZ0">void</span><span class="w" id="mwAZ4"> </span><span class="nf" id="mwAZ8">doSomething</span><span class="p" id="mwAaA">(</span><span class="k" id="mwAaE">auto</span><span class="o" id="mwAaI">&&</span><span class="p" id="mwAaM">...</span><span class="w" id="mwAaQ"> </span><span class="n" id="mwAaU">args</span><span class="p" id="mwAaY">);</span>
Note void doSomething(auto... args); is equivalent to template <typename... Ts> void doSomething(Ts... args);.
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:
<span id="mwAc4"></span><span class="k" id="mwAc8">void</span><span class="w" id="mwAdA"> </span><span class="nf" id="mwAdE">Add</span><span class="p" id="mwAdI">(</span><span class="k" id="mwAdM">out</span><span class="w" id="mwAdQ"> </span><span class="kt" id="mwAdU">int</span><span class="w" id="mwAdY"> </span><span class="n" id="mwAdc">sum</span><span class="p" id="mwAdg">,</span><span class="w" id="mwAdk"> </span><span class="k" id="mwAdo">params</span><span class="w" id="mwAds"> </span><span class="kt" id="mwAdw">int</span><span class="p" id="mwAd0">[]</span><span class="w" id="mwAd4"> </span><span class="k" id="mwAd8">value</span><span class="p" id="mwAeA">);</span> <span class="na" id="mwAeE">[...]</span> <span class="n" id="mwAeI">Add</span><span class="p" id="mwAeM">(</span><span class="k" id="mwAeQ">out</span><span class="w" id="mwAeU"> </span><span class="n" id="mwAeY">sum</span><span class="p" id="mwAec">,</span><span class="w" id="mwAeg"> </span><span class="mi" id="mwAek">3</span><span class="p" id="mwAeo">,</span><span class="w" id="mwAes"> </span><span class="mi" id="mwAew">5</span><span class="p" id="mwAe0">,</span><span class="w" id="mwAe4"> </span><span class="mi" id="mwAe8">7</span><span class="p" id="mwAfA">,</span><span class="w" id="mwAfE"> </span><span class="mi" id="mwAfI">11</span><span class="p" id="mwAfM">,</span><span class="w" id="mwAfQ"> </span><span class="o" id="mwAfU">-</span><span class="mi" id="mwAfY">1</span><span class="p" id="mwAfc">);</span><span class="w" id="mwAfg"> </span><span class="c1" id="mwAfk">// sum == 25</span>
Java
In 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:
<span id="mwAgU"></span><span class="kt" id="mwAgY">void</span><span class="w" id="mwAgc"> </span><span class="nf" id="mwAgg">doSomething</span><span class="p" id="mwAgk">(</span><span class="n" id="mwAgo">String</span><span class="o" id="mwAgs">[]</span><span class="w" id="mwAgw"> </span><span class="n" id="mwAg0">x</span><span class="p" id="mwAg4">);</span><span class="w" id="mwAg8"> </span><span class="c1" id="mwAhA">// doSomething(String[])</span> <span class="kt" id="mwAhE">void</span><span class="w" id="mwAhI"> </span><span class="nf" id="mwAhM">doSomething</span><span class="p" id="mwAhQ">(</span><span class="n" id="mwAhU">String</span><span class="w" id="mwAhY"> </span><span class="n" id="mwAhc">x</span><span class="p" id="mwAhg">);</span><span class="w" id="mwAhk"> </span><span class="c1" id="mwAho">// doSomething(String)</span>
The following two methods both have the same signature:
<span id="mwAh4"></span><span class="kt" id="mwAh8">int</span><span class="w" id="mwAiA"> </span><span class="nf" id="mwAiE">doSomething</span><span class="p" id="mwAiI">(</span><span class="kt" id="mwAiM">int</span><span class="w" id="mwAiQ"> </span><span class="n" id="mwAiU">x</span><span class="p" id="mwAiY">);</span><span class="w" id="mwAic"> </span><span class="c1" id="mwAig">// doSomething(int)</span> <span class="kt" id="mwAik">void</span><span class="w" id="mwAio"> </span><span class="nf" id="mwAis">doSomething</span><span class="p" id="mwAiw">(</span><span class="kt" id="mwAi0">int</span><span class="w" id="mwAi4"> </span><span class="n" id="mwAi8">y</span><span class="p" id="mwAjA">)</span><span class="w" id="mwAjE"> </span><span class="kd" id="mwAjI">throws</span><span class="w" id="mwAjM"> </span><span class="n" id="mwAjQ">Exception</span><span class="p" id="mwAjU">;</span><span class="w" id="mwAjY"> </span><span class="c1" id="mwAjc">// doSomething(int)</span>
Variadic parameters in Java are represented with ellipses on the final parameter. These behave identically to an array, but in the JVM bytecode the method is marked variadic.
<span id="mwAjw"></span><span class="kt" id="mwAj0">void</span><span class="w" id="mwAj4"> </span><span class="nf" id="mwAj8">doSomething</span><span class="p" id="mwAkA">(</span><span class="n" id="mwAkE">String</span><span class="p" id="mwAkI">...</span><span class="w" id="mwAkM"> </span><span class="n" id="mwAkQ">x</span><span class="p" id="mwAkU">);</span><span class="w" id="mwAkY"> </span><span class="c1" id="mwAkc">// equivalent to doSomething(String[])</span>
Julia
In Julia, function signatures take the following form:
<span id="mwAk0"></span><span class="n" id="mwAk4">commission</span><span class="p" id="mwAk8">(</span><span class="n" id="mwAlA">sale</span><span class="o" id="mwAlE">::</span><span class="kt" id="mwAlI">Int</span><span class="p" id="mwAlM">,</span><span class="w" id="mwAlQ"> </span><span class="n" id="mwAlU">rate</span><span class="o" id="mwAlY">::</span><span class="kt" id="mwAlc">Float64</span><span class="p" id="mwAlg">)</span><span class="o" id="mwAlk">::</span><span class="kt" id="mwAlo">Float64</span>
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 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.
<span id="mwAmA"></span><span class="n" id="mwAmE">commission</span><span class="p" id="mwAmI">(</span><span class="n" id="mwAmM">sale</span><span class="o" id="mwAmQ">::</span><span class="kt" id="mwAmU">Integer</span><span class="p" id="mwAmY">,</span><span class="w" id="mwAmc"> </span><span class="n" id="mwAmg">rate</span><span class="o" id="mwAmk">::</span><span class="kt" id="mwAmo">Real</span><span class="p" id="mwAms">)</span><span class="o" id="mwAmw">::</span><span class="kt" id="mwAm0">Real</span>
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 programming language, method signatures for an object are declared in the interface header file. For example,
<span id="mwAnU"></span><span class="p" id="mwAnY">-</span> <span class="p" id="mwAnc">(</span><span class="kt" id="mwAng">id</span><span class="p" id="mwAnk">)</span><span class="nf" id="mwAno">initWithInt:</span><span class="p" id="mwAns">(</span><span class="kt" id="mwAnw">int</span><span class="p" id="mwAn0">)</span><span class="nv" id="mwAn4">value</span><span class="p" id="mwAn8">;</span>
defines a method initWithInt that returns a general object (an id) and takes one integer argument. Objective-C only requires a type in a signature to be explicit when the type is not id; this signature is equivalent:
<span id="mwAow"></span><span class="p" id="mwAo0">-</span> <span class="nf" id="mwAo4">initWithInt:</span><span class="p" id="mwAo8">(</span><span class="kt" id="mwApA">int</span><span class="p" id="mwApE">)</span><span class="nv" id="mwApI">value</span><span class="p" id="mwApM">;</span>
Rust
In Rust, function signatures take the following form:
<span id="mwApk"></span><span class="k" id="mwApo">fn</span><span class="w" id="mwAps"> </span><span class="nf" id="mwApw">commission</span><span class="p" id="mwAp0">(</span><span class="n" id="mwAp4">sale</span><span class="p" id="mwAp8">:</span><span class="w" id="mwAqA"> </span><span class="kt" id="mwAqE">u32</span><span class="p" id="mwAqI">,</span><span class="w" id="mwAqM"> </span><span class="n" id="mwAqQ">rate</span><span class="p" id="mwAqU">:</span><span class="w" id="mwAqY"> </span><span class="kt" id="mwAqc">f64</span><span class="p" id="mwAqg">)</span><span class="w" id="mwAqk"> </span><span class="p" id="mwAqo">-></span><span class="w" id="mwAqs"> </span><span class="kt" id="mwAqw">f64</span><span class="p" id="mwAq0">;</span>