Understanding Pure and Impure Functions

pure-impure functions

In programming, a function is a piece of code that takes one or more inputs (called arguments) and produces an output. Functions are a fundamental building block of most programming languages, and they're used to break up complex tasks into smaller, easier-to-manage pieces.

There are two main types of functions: pure functions and impure functions. Understanding the difference between these types of functions is important because it can affect how you write and use your code. Here's a quick overview of each type of function:

Pure functions

A pure function is a function that:

• Takes one or more arguments
• Produces an output (called a return value)
• Has no side effects

A side effect is any change to the state of the program that occurs as a result of calling the function. For example, if a function modifies a global variable, that's a side effect. If a function sends an email, that's a side effect. If a function doesn't have any side effects, it's considered a pure function.

Pure functions have a number of benefits:

• They're easy to test because you can simply pass in some inputs and check the output.
• They're easy to understand because they only do one thing (take some inputs and produce an output).
• They're easy to reuse because they don't depend on any external state.
• They can make it easier to reason about your code because you don't have to worry about side effects.

Here's an example of a pure function in Java:

// Pure function example
public int add(int x, int y) {
  return x+y;
}

This function takes two arguments (x and y) and returns the sum of those arguments. It doesn't have any side effects, so it's a pure function.

Impure functions

An impure function is a function that has one or more side effects. This means that in addition to producing an output, it also changes the state of the program in some way.

Impure functions can be useful in certain situations, but they also have some drawbacks:

• They're harder to test because you have to worry about the side effects as well as the output.
• They can make it harder to reason about your code because you have to keep track of the side effects.
• They can be more difficult to reuse, because they may depend on the external state.

Here's an example of an impure function in Java:

// Impure function example 
public int addToCounter(int x) {
  counter += x;
  return counter;
}

This function takes an argument (x) and modifies a global variable (counter) by adding x to it. It also returns the new value of counter. Because it modifies a global variable, it's an impure function.

I hope this article helped you! Let me know if you have any other questions. Happy Learning !!