> For the complete documentation index, see [llms.txt](https://alex-semenov-ie.gitbook.io/book/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://alex-semenov-ie.gitbook.io/book/chapter-2-advanced-topics/functional-programming-in-q.md).

# Functional Programming in q

###

#### Introduction

Functional programming is a paradigm that emphasizes the use of pure functions and immutable data structures. It promotes code reusability, modularity, and readability. While kdb+ is primarily known for its vectorized operations, it also offers powerful functional programming capabilities. This chapter explores the functional aspects of kdb+ and how to leverage them for efficient and elegant code.

#### Pure Functions

A pure function is a function that always produces the same output for a given input and has no side effects. This means it doesn't modify any external state or rely on external variables.

Code snippet

```
f:{[x] x*2}  / Pure function to double a value
f[3]        / Output: 6
```

In this example, `f` is a pure function because it always returns double the input value, and it doesn't modify any external variables.

#### Higher-Order Functions

Higher-order functions are functions that take other functions as arguments or return functions as results.  

Code snippet

```
apply:{[f;x] f[x]}  / Apply function f to x
apply[f;4]          / Output: 8
```

Here, `apply` is a higher-order function that takes a function `f` and a value `x` as arguments, applies `f` to `x`, and returns the result.

#### Recursion

Recursion is a technique where a function calls itself directly or indirectly.

Code snippet

```
factorial:{[n] if[n<=1; 1; n*factorial[n-1]]}
factorial[5]  / Output: 120
```

The `factorial` function calculates the factorial of a number recursively.

#### Lambda Functions

Lambda functions are anonymous functions defined inline.

Code snippet

```
{x*2}[5]  / Output: 10
```

This lambda function squares the input value and applies it to 5.

#### Functional Operators

kdb+ provides several functional operators that make it easy to apply functions to lists:

* **each:** Applies a function to each element of a list.Code snippet

  ```
  {x*2} each 1 2 3  / Output: 2 4 6
  ```
* **over:** Applies a function pairwise to two lists.Code snippet

  ```
  {x+y} over (1 2 3; 4 5 6)  / Output: 5 7 9
  ```
* **where:** Filters a list based on a predicate function.Code snippet

  ```
  {x>2} where 1 2 3 4  / Output: 3 4
  ```

#### Functional Composition

Functional composition involves combining multiple functions into a single function.

Code snippet

```
f:{[x] x*2}
g:{[x] x+1}
h:{[x] g[f[x]]}
h[3]  / Output: 7
```

The `h` function composes `f` and `g`, applying `f` first and then `g`.

#### Advanced Topics

* **Currying:** Creating new functions by partially applying arguments.
* **Monads:** Structures that represent computations with side effects in a pure context.
* **Functional Reactive Programming (FRP):** A programming paradigm for managing stateful systems in a declarative way.

#### Conclusion

Functional programming offers a powerful and expressive way to write code in kdb+. By understanding and applying these concepts, you can write cleaner, more maintainable, and often more efficient code. While kdb+ is primarily known for its vectorized operations, combining functional programming with vectorization can lead to even greater performance gains.