Functional Programming Concepts

Pure Functions:

Pure functions are functions that always produce the same output for the same input and have no side effects. They do not modify any external state or variables and have no dependencies on the state of the system. Pure functions are deterministic and predictable.

Example of a Pure Function:

import java.util.function.Function;

public class PureFunctionExample {
    public static void main(String[] args) {
        Function<Integer, Integer> addTwo = number -> number + 2;
        int result = addTwo.apply(3); // Output: 5
        System.out.println(result);
    }
}

In the above example, the addTwo function is a pure function because it always produces the same output (input + 2) for the same input.

Immutability:

Immutability means that once an object is created, its state cannot be changed. In functional programming, immutable objects are preferred because they simplify reasoning about the code. Immutable objects are thread-safe and reduce the chance of bugs related to mutable state.

Example of Immutability:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ImmutableExample {
    public static void main(String[] args) {
        List<String> mutableList = new ArrayList<>();
        mutableList.add("Java");
        mutableList.add("Python");

        // Creating an immutable copy of the list
        List<String> immutableList = Collections.unmodifiableList(new ArrayList<>(mutableList));

        // This will throw an UnsupportedOperationException
        immutableList.add("JavaScript");
    }
}

In the above example, immutableList is an immutable copy of mutableList. Attempting to modify the immutable list will result in an UnsupportedOperationException.

First-Class and Higher-Order Functions:

First-class functions treat functions as first-class citizens, allowing them to be passed as arguments to other functions, returned as values from other functions, and assigned to variables.

Higher-order functions are functions that take one or more functions as arguments or return a function as a result.

Example of First-Class and Higher-Order Functions:

import java.util.function.Function;

public class HigherOrderFunctionExample {
    public static void main(String[] args) {
        // Higher-order function taking a function as an argument
        Function<Integer, Integer> square = number -> number * number;

        // First-class functions: passing a function as an argument
        int result = applyFunction(square, 3); // Output: 9
        System.out.println(result);
    }

    // Higher-order function taking a function as an argument
    public static int applyFunction(Function<Integer, Integer> func, int number) {
        return func.apply(number);
    }
}

In the above example, applyFunction is a higher-order function that takes a function as an argument and applies it to a number. The square function is a first-class function passed to applyFunction.

Understanding and applying these functional programming concepts can lead to more robust, maintainable, and parallelizable code, especially in the context of concurrent and distributed systems. Functional programming encourages the use of these concepts, making your code more predictable and easier to reason about.