> For the complete documentation index, see [llms.txt](https://jazz-lang.gitbook.io/jazz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jazz-lang.gitbook.io/jazz/generics.-part-2.md).

# Generics. Part 2

## Generic functions

*Generic functions* can work with any type. Here’s a generic version of the `swapTwoInts` function from above, called `swap`:

```kotlin
fun swap<T>(x: T*,y: T*) {
    var temp = x;
    *x = *y;
    *y = *x;
}
```

The generic version of the function uses a *placeholder* type name (called `T`, in this case) instead of an *actual* type name (such as `int`, `String`, or `float64`). The placeholder type name doesn’t say anything about what `T` must be, but it *does* say that both `x` and `y` must be of the same type `T`, whatever `T` represents. The actual type to use in place of `T` is determined each time the `swap` function is called.

The other difference between a generic function and a non generic function is that the generic function’s name (`swap`) is followed by the placeholder type name (`T`) inside angle brackets (`<T>`). The brackets tell Jazz that `T` is a placeholder type name within the `swap` function definition.&#x20;

The `swap` function can now be called in the same way as `swapTwoInts`, except that it can be passed two values of *any* type, as long as both of those values are of the same type as each other. Each time `swap` is called, the type to use for `T` is inferred from the types of values passed to the function.

Example:

```kotlin
fun main() {
    var x = 0;
    var y = 42;
    swap(&x,&y); // types inferred automatically to `int`
}
```