How can you ensure a function is pure in your programming?

Pure function is not just a design pattern, it makes your code reusable, scalable etc. The golden rule of programming is to write your programs the way that you expect other's code when you are reviewing it.

According to me pure functions can be used in Java Functional Programming. In Java 8 we can use Streams api , Functional interfaces , Lambda expressions

Pure function is one that delivers the same result every single time given the same set of inputs. Pure functions are faster and use less memory than regular functions because they don't change the global state. Pure functions are reusable. Pure functions are referential transparent means we can change the value of expression with its value. As input and output behaviour are the same or defined already, so testing it becomes easier and makes debugging easier. And the output is only dependent on input. Pure functions are also small, precise, simple, safe, and straightforward to reuse. They guarantee that they will not modify anything outside their body.

Pure functions aren't just a design pattern; they're keystones for reusable, scalable code. In programming's golden rule, envision your code as you'd review others'. A pure function, deterministic and side-effect-free, ensures consistent output with the same input. This predictability fosters reliability and clarity. Swati Garg emphasizes that such functions offer predictability, reusability, and simplified testing. They thrive in concurrent environments, ensuring thread safety and data integrity. Yatharth Dixit concurs, defining pure functions as consistent, side-effect-free entities. So, follow this programming virtuosity: code purity breeds reliability, scalability, and ease of understanding.

A pure function: Deterministic: Given the same input, a pure function will always produce the same output. This predictability?makes your code more reliable and easier to reason about. No side effects: Pure functions do not modify external state, variables, or any data outside their own scope.

Impure functions can be identified by their ability to modify data outside of their own scope or by producing different results for the same input.

An impure function is a function that does not always return the same output for the same input and/or has side effects. A side effect is any change that a function makes to the state of the program outside of its own scope. For example, if a function modifies a global variable or reads input from the user, it is likely impure. Similarly, if a function calls another function that is impure, it is also impure by extension. Consider a function that takes a number as input and returns the total + number, total = 200 def add_to_total(x): global total total += x return total print(add_to_total(5)) This function is impure because it modifies the total variable outside of its scope.

An impure function is a function that contains one or more side effects. It mutates data outside of its lexical scope and does not predictably produce the same output for the same input. In the above example, there is a variable named addNew, and it is declared outside of the add() function. Impure functions, on the other hand, can have unpredictable behavior and can modify the state of the application or have side effects.

Here's how to identify impure functions in 3 steps: Check for side effects: If a function modifies any variables, objects, or state outside of its scope, it's impure. Look for external dependencies: If a function relies on global variables, mutable objects, or I/O operations, it's likely impure. Test for consistency: If a function produces different outputs for the same input under different conditions, it's impure.

For example this is an impure function in Python: def add_to_list(value, my_list): my_list.append(value) return len(my_list) In this function `add_to_list`, it takes a value and a list as input parameters. However, it modifies the list (`my_list`) by appending the `value` to it. This action changes the external state of the list, making the function impure. Additionally, the function returns the length of the modified list, which could vary depending on the state of `my_list` when the function is called.

When we write code, we want to make sure that it does what we expect it to do and doesn’t have any unintended consequences. One way to do this is to avoid side effects in our code. A side effect is when a function changes something outside of itself, like a global variable or a file on your computer. This can make it harder to understand and test your code. To avoid side effects, we can try to write pure functions. A pure function is a function that always returns the same output for the same input and doesn’t change anything outside of itself. For example, a function that adds two numbers together is a pure function because it always returns the same result for the same input, and it doesn’t change anything outside of itself.

If you're writing code in Java, using the 'final' keyword is a simple way to ensure the variables inside your method are not wrongly being overwritten. Instead of writing int hoursInDay = 24; try final int hoursInDay = 24; The compiler ensures you're not unknowingly changing the value and introducing side effects.

In addition to the points previously noted, Testing, especially unit testing, can help catch and prevent unintended side effects. Another one would be, Code Reviews. Regularly conducting code reviews can catch potential side effects and ensure compliance to coding standards and best practices .

One of the best ways to avoid side effects in our program is to use pure functions, remember when we were talking about the quality of a good function, we said a function must be pure to meet the requirements of a quality function. we'll look at some significance of using pure functions. Significance: Predictability: when we write pure functions, we always know what to expect because it has no effect on the outside variable. Test: It makes the function easy to test. Composition: composition is the act of using smaller pieces of code to create bigger ones the compose() method is an example of this. Immutability: means inability to change a data or a state, by writing pure functions we make copies instead of changing the original data

Refactoring these functions won't change others in your program since they were never connected to begin with. It's also important to note what pure functions don't do. They shall not cause side effects such as altering the arguments that were passed in, changing your application's state, setting/updating global variables, or any other side effect like triggering a fetch request. They're simple and only depend on their arguments to compute and return a value.

The first test of function's purity is to take it out of its lexical scope. We can do this by reconstructing it in a new global lexical scope using new Function . This returns a new function that evaluates the given function's source code in new lexical scope. Let us refactor the code a little before proceeding. JavaScript uses lexical scope to find variables.