# Introductory TyDD in Scala: Anatomy of a Type Level Function

## Value Level Functions

A value level function typically looks like

```def f(a: Int, b: Int): String = {
a.toString + b.toString
}
```

The key parts are

1. A keyword: def
2. Inputs: a: Int, b: Int
3. Outputs: String
4. Body: a.toString + b.toString

When you see these 4 parts, you know you are reading a value level function. Nothing surprising here. Now, let's see what a similar definition looks like at the type level.

## Type Level Functions

A type level function looks like

```trait MyTrait[A, B]{type Out}
object MyTrait{
def apply[A, B, C](): MyTrait[A, B]{type Out = C} =
new MyTrait[A, B]{override type Out = C}
}
```

In this definition there is a type refinement, MyTrait[A, B]{type Out = C}. These are undesirable artifacts of type level development. To simplify these definitions we use the Aux alias (a document about on this). Aux helps us remove type refinements from our logic.

A type level function looks like

```trait MyTrait[A, B]{type Out}
object MyTrait{
type Aux[A, B, C] = MyTrait[A, B]{type Out = C}
def apply[A, B, C](): Aux[A, B, C] =
new MyTrait[A, B]{override type Out = C}
}
```

The type refinement from the previous example is replaced by the nicer (more readable, fewer braces, less code) Aux type.

Type level functions have the same 4 key parts as value level functions

1. Keywords: trait object
2. Inputs: A, B
3. Outputs: type Out
4. Body: def apply[A, B, C](): Aux[A, B, C]

Here the inputs are type parameters and outputs are type members. This is so the output types are not erased and can be referenced later in business logic. This is similar to value level functions as the result of a value level function does not expose the inputs required by the function.

Bodies of type level functions are value level functions. They are typically only a few lines long. Their purpose is to present the compiler with a way to construct a new type from the types provided. This is what these blog posts will focus on.

Whenever you see a set of definitions which have these 4 qualities, you know you are looking at a type level function.

The type class is the fundamental element of this style of type driven development. The next post will give an overview of this concept.