Functional Programming

        // => PROBLEM 3: Cannot parallelize safely
    }
}

// => SOLUTION: Pure function (no side effects)
public class Calculator {
    public static int add(int x, int y) {
        return x + y;
        // => PURE: Same inputs always produce same output
        // => NO SIDE EFFECTS: Doesn't modify external state
        // => NO I/O: Doesn't interact with outside world
        // => REFERENTIALLY TRANSPARENT: Can replace add(2, 3) with 5
        // => PARALLELIZABLE: Safe to call concurrently
        // => TESTABLE: No mocking needed, just input to output
    }
}

Function<String, Integer> stringLength = s -> s.length();
// => TRANSFORMATION: String to Integer (measures length)
// => Example: "hello" maps to 5
Function<Integer, String> formatNumber = n -> String.format("Value: %d", n);
// => TRANSFORMATION: Integer to String (formatting)
// => Example: 42 maps to "Value: 42"

// => COMPOSITION: andThen (left to right execution)
Function<String, String> pipeline =
    stringLength.andThen(n -> n * 2).andThen(n -> "Result: " + n);
// => PIPELINE: stringLength (String to Integer)
// => THEN: multiply by 2 (Integer to Integer)
// => THEN: format as string (Integer to String)
// => Example: "hello" to 5 to 10 to "Result: 10"

// => COMPOSITION: compose (right to left, mathematical notation)
Function<Integer, Integer> composed =
    addFive.compose(multiplyByTwo);
// => EXECUTE: multiplyByTwo FIRST (right side)
// => THEN: addFive (left side)
// => Example: 3 to 6 (multiply) to 11 (add five)
// => Mathematical: f(g(x)) where f = addFive, g = multiplyByTwo

### Predicate Interface - Filtering

Predicate<T> represents boolean-valued functions for testing conditions.

```java
Predicate<Integer> isPositive = n -> n > 0;
// => TEST: Returns true if n > 0, false otherwise
Predicate<Integer> isEven = n -> n % 2 == 0;
// => TEST: Returns true if even, false if odd

// => LOGICAL COMPOSITION: and, or, negate
Predicate<Integer> isEvenAndPositive = isEven.and(isPositive);
// => COMBINED: true only if BOTH even AND positive
// => Example: 4 returns true, -4 returns false, 3 returns false
Predicate<Integer> isOddOrNegative = isEven.negate().or(isPositive.negate());
// => COMBINED: true if NOT even OR NOT positive
// => negate() inverts predicate result
// => Example: 3 returns true (odd), -2 returns true (negative)

**Comparison:**

| Pattern            | Imperative             | Declarative (Predicate)        |
| ------------------ | ---------------------- | ------------------------------ |
| Filter list        | `for` loop with `if`   | `.filter(predicate)`           |
| Complex conditions | Nested `if` statements | `.and()`, `.or()`, `.negate()` |
| Reusability        | Copy-paste logic       | Reference predicate            |
| Testing            | Test entire method     | Test predicate in isolation    |

### Consumer and Supplier - Side Effects and Lazy Evaluation

**Consumer<T>**: Accepts input, performs side effects, returns nothing (void).

```java
Consumer<Transaction> logTransaction = t ->
    System.out.println("[LOG] " + t.id());
// => SIDE EFFECT: Writes to console (no return value)
Consumer<Transaction> auditTransaction = t ->
    System.out.println("[AUDIT] " + t.id());
// => SIDE EFFECT: Audit logging

// => PIPELINE: Chain consumers for sequential side effects
Consumer<Transaction> processTransaction =
    logTransaction.andThen(auditTransaction);
// => EXECUTION: logTransaction FIRST, then auditTransaction
// => Example: processTransaction.accept(tx) logs then audits

// => SUPPLIER: Lazy value generation (no inputs)
Supplier<String> expensiveOperation = () -> computeResult();
// => DEFERRED: Not executed until get() called
// => Returns: Result of computeResult()

// => LAZY EVALUATION with Optional
String result = maybeName.orElseGet(() -> expensiveOperation());
// => LAZY: expensiveOperation only called if maybeName empty
// => EAGER alternative: orElse(expensiveOperation.get())
// => Would call expensiveOperation ALWAYS (wasteful)

| Use Case     | Consumer                | Supplier               |
| ------------ | ----------------------- | ---------------------- |
| Purpose      | Perform side effects    | Generate values lazily |
| Input        | One parameter           | No parameters          |
| Output       | Void                    | Value of type T        |
| Common usage | Event handlers, logging | Defaults, factories    |

## Method References - Concise Syntax

Method references provide shorthand for lambdas that just call existing methods.

**Four types:**

| Type               | Syntax               | Lambda Equivalent           |
| ------------------ | -------------------- | --------------------------- |
| Static method      | `Integer::parseInt`  | `s -> Integer.parseInt(s)`  |
| Instance (bound)   | `text::length`       | `() -> text.length()`       |
| Instance (unbound) | `String::trim`       | `s -> s.trim()`             |
| Constructor        | `StringBuilder::new` | `s -> new StringBuilder(s)` |

**When to use:**

- ✓ Single method call without additional logic
- ✓ Method signature matches functional interface
- ✓ Improves readability over lambda
- ✗ Multiple statements needed
- ✗ Argument transformation required

**Stream example:**

```java
List<String> words = List.of("apple", "banana", "cherry");

words.stream()
    .map(String::toUpperCase)  // METHOD REFERENCE
    .filter(w -> w.startsWith("A"))  // LAMBDA (condition check)
    .forEach(System.out::println);  // METHOD REFERENCE

// => IMPERATIVE: How to do it (step-by-step mutation)
List<Integer> result = new ArrayList<>();
// => MUTABLE: Empty list, will be modified
for (Integer n : numbers) {
    // => LOOP: Manual iteration
    if (n % 2 == 0) {
        // => FILTER: Check each element
        result.add(n * 2);
        // => SIDE EFFECT: Mutate result list
    }
}
// => Result: List of even numbers doubled

// => DECLARATIVE: What to do (express intent)
List<Integer> result = numbers.stream()
    .filter(n -> n % 2 == 0)
    // => FILTER: Keep only even numbers
    // => Example: [1,2,3,4] becomes [2,4]
    .map(n -> n * 2)
    // => MAP: Transform each element (double it)
    // => Example: [2,4] becomes [4,8]
    .toList();
    // => COLLECT: Gather results into immutable list
// => NO MUTATION: Original numbers unchanged
// => FUNCTIONAL: Describes transformation pipeline

Stream<Integer> stream = numbers.stream()
    .filter(n -> {
        System.out.println("Filtering: " + n);  // NOT executed yet
        // => LAZY: No processing happens at stream creation
        return n > 0;
    });
// => NO OUTPUT YET: Intermediate operations are lazy
// => Stream is just a recipe, not executed

List<Integer> result = stream.toList();
// => TERMINAL OPERATION: NOW executes entire pipeline
// => Output: "Filtering: 1", "Filtering: 2", etc.
// => Benefits: Short-circuit optimization, infinite streams support

Function<String, String> sanitize = String::trim;
// => TRANSFORMATION: Remove whitespace
Function<String, String> normalize = String::toLowerCase;
// => TRANSFORMATION: Lowercase conversion
Function<String, Integer> countWords = s -> s.split("\\s+").length;
// => TRANSFORMATION: Count words by splitting on whitespace

Function<String, Integer> pipeline =
    sanitize.andThen(normalize).andThen(countWords);
// => COMPOSITION: Chain three functions left-to-right
// => EXECUTION: sanitize → normalize → countWords
// => Example: "  Hello WORLD  " → "hello world" → 2
// => REUSABLE: Single pipeline, multiple invocations

Optional<Address> address = findUser(userId)
    .flatMap(User::getAddress)
    // => flatMap: Flattens Optional<Optional<Address>> to Optional<Address>
    // => User::getAddress returns Optional<Address>
    // => Without flatMap: Would get Optional<Optional<Address>> (nested)
    // => SHORT-CIRCUIT: If user absent, skips remaining operations
    .filter(addr -> addr.isValid());
    // => FILTER: Keep address only if valid
    // => Returns: Optional.empty() if invalid
// => NO NULL CHECKS: Entire chain handles absence functionally
// => COMPOSABLE: Can add more operations with map/flatMap/filter

long count = hugeList.parallelStream()
    // => PARALLEL: Splits collection across multiple threads
    // => ForkJoinPool: Uses common pool by default
    .filter(isPrime)
    // => PURE FUNCTION: No side effects, safe to parallelize
    // => THREAD SAFE: Each thread filters independently
    // => STATELESS: No shared mutable state
    .count();
    // => REDUCTION: Combines results from all threads
// => AUTOMATIC: No explicit thread management needed
// => PERFORMANCE: Speedup proportional to cores (if work is CPU-bound)

// => BEFORE: Mixed logic (impure)
public double calculateDiscount(Order order) {
    double total = 0;
    // => MUTABLE STATE: Accumulator variable
    for (Item item : order.getItems()) {
        total += item.getPrice();
        // => MUTATION: Modifying total
    }
    return total > 100 ? total * 0.1 : 0;
    // => MIXED CONCERNS: Calculation + business rule
}

// => AFTER: Pure extraction (functional)
public double calculateDiscount(Order order) {
    double total = calculateTotal(order);
    // => PURE FUNCTION: No side effects
    // => TESTABLE: Easy to verify correctness
    return applyDiscountRule(total);
    // => PURE FUNCTION: Single responsibility
    // => COMPOSABLE: Can reuse independently
}
// => BENEFITS: Easier testing, clearer intent, reusable logic