Explain the concept of currying in Haskell and how it relates to function composition.

Currying is a fundamental concept in Haskell that allows functions to be partially applied by transforming a function that takes multiple arguments into a sequence of functions, each taking a single argument. It is named after the mathematician Haskell Curry, who made significant contributions to the theory of functional programming.

In Haskell, every function is considered to be a function of a single argument. If a function is defined with multiple parameters, currying allows you to create a chain of functions, each taking one argument and returning a new function until all the arguments are supplied.

Let's illustrate currying with an example. Consider a function `add` that takes two integers and returns their sum:

```
haskell`add :: Int -> Int -> Int
add x y = x + y`
```
By default, this function appears to take two arguments. However, in Haskell, we can interpret it as a function that takes a single argument `x` and returns another function that takes an argument `y` and computes the sum. This allows for partial application, where you can create new functions by supplying fewer arguments than the original function expects.

For example, we can partially apply the `add` function to create a new function `increment` that adds `1` to any given number:

```
haskell`increment :: Int -> Int
increment = add 1`
```
In this case, `add 1` returns a new function that takes a single argument `y` and computes `1 + y`. The result is a function `increment` that can be called with a single argument, adding `1` to it.

Currying enables powerful function composition in Haskell. Function composition is the process of combining multiple functions to create a new function. Since every function in Haskell is curried, function composition becomes natural and straightforward.

Haskell provides the function composition operator `(.)`, which allows you to compose functions together. The `(.)` operator takes two functions `f` and `g` and returns a new function that applies `f` to the result of applying `g` to an argument.

Here's an example to demonstrate function composition:

```
haskell`addOneAndDouble :: Int -> Int
addOneAndDouble = double . increment`
```
In this example, we define a new function `addOneAndDouble` that is obtained by composing the `increment` function and the `double` function. The `increment` function adds `1` to its argument, and the `double` function doubles its argument. By composing them together, we obtain a new function that first increments the argument and then doubles the result.

Currying allows us to break down complex computations into smaller, reusable functions and then compose them together to create more complex and expressive functions. It promotes code modularity, reusability, and clarity by separating concerns and enabling function composition.

In summary, currying in Haskell transforms functions with multiple arguments into a sequence of functions, each taking a single argument. It enables partial application and function composition, allowing for more flexible and expressive code. Currying plays a fundamental role in functional programming and is a powerful tool in Haskell's toolbox.