Signature de type

In computer science, a type signature or type annotation defines the inputs and outputs for a function, subroutine 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. 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 would be called as: char c; double d; int retVal = (*fPtr)(c, d); In Erlang, type signatures may be optionally declared, as: spec function_name(type1(), type2(), ...) -> out_type(). For example: spec is_even(number()) -> boolean(). 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. 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 as .