Type signatures are written with [hindley-milner syntax](https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system).

They take the form
```text
{function} :: {type variables} {constraints} {arguments} {return type}
```

where:
- `{function}` is the [[Functions|function]] name
- `{type variables}` defines a list of type variables that are initially unconstrained; they could be literally anything.
- `{constraints}` is a list of 0 or more [[Typeclasses|typeclass]] constraints that need to be met in order to apply the function
- `{arguments}` is a list of 0 or more arguments
- `{return type}` is the type returned by the function

### Type Variables
Type variables are a list of camelCase generic type parameters.

```text
forall a.
```
Defines 1 type variable `a`.

```text
forall a b c.
```
Defines 3 type variables `a`, `b` and `c`.

### Constraints
List of typeclass constraints that must be true in order to apply the function, separated by `=>`

```text
forall a. Show a => ..
```
for any `a` that is `Show`able

```text
forall a b. Show a => Eq b => ..
```
for any `a` and `b`, provided that `a` is `Show`able and `b` can be compared for `Eq`uality.

### Arguments
Function arguments, separated by `->`

```text
String
```
constant (function with 0 arguments) of type `String`

```text
a -> b
```
function from `a` to `b` (1 argument)

```text
a -> b -> c
```
function from `a` to `b` to `c` (2 arguments; `a` & `b`)

### Examples

```haskell
identity :: forall a. a -> a
```
`identity` is `a` to `a` for any `a`

```haskell
split :: String -> String -> String
```
split is `String` to `String` to `String`.

```haskell
sum :: forall f a. Foldable f => Semiring a => f a -> a
```
`sum` is `f` of `a` to `a`, for any collection<sup>[[Foldable]]</sup> `f` and any type supporting addition<sup>[[Semiring]]</sup> `a`
