Java Functional Programming rules
Identify and apply functional programming principles in Java to improve immutability, expressiveness, and maintainability.
What is covered in this Skill?
- Immutable objects and Records (JEP 395)
- Pure functions free of side effects
- Functional interfaces:
Function, Predicate, Consumer, Supplier, custom @FunctionalInterface
- Lambda expressions and method references
- Stream API: filter/map/reduce pipelines, parallel streams,
toUnmodifiable* collectors
Optional idiomatic usage: map/flatMap/filter/orElse* over isPresent()+get()- Function composition:
andThen/compose
- Higher-order functions: memoization, currying, partial application
- Pattern Matching for
instanceof and switch (Java 21)
- Sealed classes and interfaces (Java 17) for exhaustive domain hierarchies
- Switch Expressions (Java 14), Stream Gatherers (JEP 461)
- Effect-boundary separation: side effects at edges, pure core logic
- Immutable collections:
List.of(), Collectors.toUnmodifiableList()
Scope: The reference is organized by examples (good/bad code patterns) for each core area. Apply recommendations based on applicable examples.
Constraints
Before applying any functional programming changes, ensure the project compiles. If compilation fails, stop immediately — do not proceed until the project compiles successfully. Verify that maven-compiler-plugin source/target supports the Java features being used.
- MANDATORY: Run
./mvnw compile or mvn compile before applying any changes
- SAFETY: If compilation fails, stop immediately — do not proceed until the project compiles successfully
- VERIFY: Verify maven-compiler-plugin source/target supports the Java features being used
- VERIFY: Run
./mvnw clean verify or mvn clean verify after applying improvements
- BEFORE APPLYING: Read the reference for detailed good/bad examples, constraints, and safeguards for each functional programming pattern
- EDGE CASE: If request scope is ambiguous, stop and ask a clarifying question before applying changes
- EDGE CASE: If required inputs, files, or tooling are missing, report what is missing and ask whether to proceed with setup guidance
When to use this skill
- Improve the code with Functional Programming
- Apply Functional Programming
- Refactor the code with Functional Programming
- Refactor Java code to use streams or Optionals safely
- Improve immutability and pure functions in Java
Workflow
- Compile project before functional refactoring
Run ./mvnw compile or mvn compile and stop immediately if compilation fails.
- Confirm Java feature compatibility
Verify maven-compiler-plugin source/target supports the functional features planned for adoption.
- Read functional-programming reference and assess code
Read references/142-java-functional-programming.md and identify opportunities for immutability, pure functions, and functional composition.
- Apply functional programming improvements
Implement selected functional refactorings while keeping side effects at boundaries.
- Verify with full build
Run ./mvnw clean verify or mvn clean verify after applying improvements.
Reference
For detailed guidance, examples, and constraints, see references/142-java-functional-programming.md.
1---
2name: 142-java-functional-programming
3description: Use when you need to apply functional programming principles in Java — including writing immutable objects and Records, pure functions, functional interfaces, lambda expressions, Stream API pipelines, Optional for null safety, function composition, higher-order functions, pattern matching for instanceof and switch, sealed classes/interfaces for controlled hierarchies, Stream Gatherers for custom operations, currying/partial application, effect boundary separation, and concurrent-safe functional patterns. This should trigger for requests such as Improve the code with Functional Programming; Apply Functional Programming; Refactor the code with Functional Programming; Refactor Java code to use streams or Optionals safely; Improve immutability and pure functions in Java. Part of Plinth Toolkit
4license: Apache-2.0
5metadata:
6 author: Juan Antonio Breña Moral
7 version: 0.18.0
8---
9
10# Java Functional Programming rules
11
12Identify and apply functional programming principles in Java to improve immutability, expressiveness, and maintainability.
13
14**What is covered in this Skill?**
15
16- Immutable objects and Records (JEP 395)
17- Pure functions free of side effects
18- Functional interfaces: `Function`, `Predicate`, `Consumer`, `Supplier`, custom `@FunctionalInterface`
19- Lambda expressions and method references
20- Stream API: filter/map/reduce pipelines, parallel streams, `toUnmodifiable*` collectors
21- `Optional` idiomatic usage: `map`/`flatMap`/`filter`/`orElse*` over `isPresent()`+`get()`
22- Function composition: `andThen`/`compose`
23- Higher-order functions: memoization, currying, partial application
24- Pattern Matching for `instanceof` and `switch` (Java 21)
25- Sealed classes and interfaces (Java 17) for exhaustive domain hierarchies
26- Switch Expressions (Java 14), Stream Gatherers (JEP 461)
27- Effect-boundary separation: side effects at edges, pure core logic
28- Immutable collections: `List.of()`, `Collectors.toUnmodifiableList()`
29
30**Scope:** The reference is organized by examples (good/bad code patterns) for each core area. Apply recommendations based on applicable examples.
31
32## Constraints
33
34Before applying any functional programming changes, ensure the project compiles. If compilation fails, stop immediately — do not proceed until the project compiles successfully. Verify that maven-compiler-plugin source/target supports the Java features being used.
35
36- **MANDATORY**: Run `./mvnw compile` or `mvn compile` before applying any changes
37- **SAFETY**: If compilation fails, stop immediately — do not proceed until the project compiles successfully
38- **VERIFY**: Verify maven-compiler-plugin source/target supports the Java features being used
39- **VERIFY**: Run `./mvnw clean verify` or `mvn clean verify` after applying improvements
40- **BEFORE APPLYING**: Read the reference for detailed good/bad examples, constraints, and safeguards for each functional programming pattern
41- **EDGE CASE**: If request scope is ambiguous, stop and ask a clarifying question before applying changes
42- **EDGE CASE**: If required inputs, files, or tooling are missing, report what is missing and ask whether to proceed with setup guidance
43
44## When to use this skill
45
46- Improve the code with Functional Programming
47- Apply Functional Programming
48- Refactor the code with Functional Programming
49- Refactor Java code to use streams or Optionals safely
50- Improve immutability and pure functions in Java
51
52## Workflow
53
541. **Compile project before functional refactoring**
55
56Run `./mvnw compile` or `mvn compile` and stop immediately if compilation fails.
57
582. **Confirm Java feature compatibility**
59
60Verify maven-compiler-plugin source/target supports the functional features planned for adoption.
61
623. **Read functional-programming reference and assess code**
63
64Read `references/142-java-functional-programming.md` and identify opportunities for immutability, pure functions, and functional composition.
65
664. **Apply functional programming improvements**
67
68Implement selected functional refactorings while keeping side effects at boundaries.
69
705. **Verify with full build**
71
72Run `./mvnw clean verify` or `mvn clean verify` after applying improvements.
73
74## Reference
75
76For detailed guidance, examples, and constraints, see [references/142-java-functional-programming.md](references/142-java-functional-programming.md).
gabrielmoreira