Conditional is a Java utility-library designed to replace if-else statements and ternary operators with a featured fluent interface. The library directs developers towards expressing boolean conditional logic in a linear format, fostering clear and streamlined execution flows. By markedly reducing the cognitive complexity typically caused by if-else structures, Conditional makes the codebase more readable, simplifying testing and debugging processes.
Significantly, the library doesn’t make use of any if-else statement or ternary operator inside.
-
The core class of the library is
eu.ciechanowiec.conditional.Conditional. It can be instantiated via a staticconditional(boolean describedValue)method. That method accepts a boolean argument (true/false), which becomes an immutable value described by a constructedConditional. Described value determines behavior of a given instance ofConditional. -
To a given instance of
Conditionalmultiple actions can be submitted in a fluent manner. -
Every submitted action is bound either to a
trueorfalseboolean value, depending on the used submission method. -
Submitted actions are supposed to be executed in a void manner or to be executed and return a value in the result of that execution. To achieve that, usage of
Conditionalis finalized via anexecute(…)orget(…)methods respectively, that trigger actions bound to a value described by a given instance ofConditional. -
Conditionalis lazy, which means that respective submitted actions will be triggered when and only when anexecute(…)orget(…)methods are called, hence mere submission of an action doesn’t suffice to trigger that action.
Conditional library is extremely lightweight (~20 KB). To use it, the following Maven dependency can be added to a project:
<dependency>
<groupId>eu.ciechanowiec</groupId>
<artifactId>conditional</artifactId>
<version>1.0.5</version>
</dependency>Conditional:import static eu.ciechanowiec.conditional.Conditional.conditional;
public static void main(String[] args) {
conditional(10 % 2 == 0) (1)
.onTrue(() -> System.out.println("Checked number is even")) (2)
.onFalse(() -> System.out.println("Checked number is odd")) (3)
.execute(); (4)
}Checked number is even
-
Constructs an instance of
Conditionalthat in this case describes atrueboolean value. -
Submits a void action to this
Conditionaland bounds it to atruevalue. -
Submits a void action to this
Conditionaland bounds it to afalsevalue. -
Executes all submitted actions, bound to the value described by this
Conditional, i.e. bound to atruevalue in this case.
if-else:public static void main(String[] args) {
if (10 % 2 == 0) {
System.out.println("Checked number is even");
} else {
System.out.println("Checked number is odd");
}
}Conditional:import static eu.ciechanowiec.conditional.Conditional.conditional;
public static void main(String[] args) {
String evenOrOdd = evenOrOdd(10);
System.out.println("Result: " + evenOrOdd);
}
private static String evenOrOdd(int numToCheck) {
return conditional(numToCheck % 2 == 0) (1)
.onTrue(() -> {
System.out.println("Returning a value on true...");
return "Even!";
}) (2)
.onFalse(() -> "Odd!") (3)
.get(String.class); (4)
}Returning a value on true... Result: Even!
-
Constructs an instance of
Conditionalthat in this case describes atrueboolean value. -
Submits an action to this
Conditionaland bounds it to atruevalue. The action printsReturning a value on true…and returnsEven!when triggered. -
Submits an action to this
Conditionaland bounds it to afalsevalue. The action returnsOdd!when triggered. -
Executes a respective action submitted to this
Conditionaland bound to the value described by thisConditional, i.e. bound to atruevalue in this case. After that, returns a return value that is produced in the result of execution of the action, but cast into a specified type (intoStringin this case).
if-else:public static void main(String[] args) {
String evenOrOdd = evenOrOdd(10);
System.out.println("Result: " + evenOrOdd);
}
private static String evenOrOdd(int numToCheck) {
if (numToCheck % 2 == 0) {
System.out.println("Returning a value on true...");
return "Even!";
} else {
return "Odd!";
}
}if-else statements are fundamental in controlling the flow of logic in programming. They dictate the execution path based on conditional evaluations. However, the extensive use of if-else statements, especially in complex methods or processes, significantly increases cognitive complexity. This complexity arises because each if-else block represents a decision point, and when numerous such blocks are present, programmers must keep track of multiple potential execution paths and outcomes. This requirement to constantly map and predict the flow of logic can become mentally taxing, reducing the overall readability and understandability of the code.
The cognitive complexity escalates dramatically when if-else statements are nested. Nested structures require developers to understand not just the individual conditions, but also how these conditions interact with and depend on each other. Each level of nesting adds another layer of complexity, making it more challenging to trace the logic and predict the behavior of the code. This complexity is not merely linear; it compounds with each additional layer, leading to a situation where understanding the full scope of the logic requires deep and often exhaustive analysis.
Over time, as software evolves, if-else blocks often undergo modifications and extensions. During maintenance, new conditions are frequently added to existing structures, sometimes in a haphazard or unplanned manner. This can lead to even more convoluted and chaotic logic, further increasing the cognitive complexity. Developers working on such code must not only grapple with the existing complex conditions but also with the intricacies introduced by ongoing changes. This often results in a codebase that is difficult to debug, test, and extend, as each addition or alteration has the potential to affect the logic flow in unpredictable ways.
A prime example of the impact of excessive if-else usage can be seen in the updateField(…) method of the org.apache.felix.scr.impl.inject.field.FieldHandler class within the Apache Felix framework (link). This method is composed of 24 if-else statements, which are spread across 125 lines and include up to four levels of nested if-else blocks. The intricate nesting results in 20 different behavioral permutations based solely on the if-else logic. This means there are 20 distinct paths the execution flow might take within just this single method. The sheer volume and complexity of these conditional statements significantly elevate the cognitive load, rendering the method challenging to comprehend, debug, and test effectively. This case illustrates how deep nesting and overuse of if-else statements can lead to a substantial increase in cognitive complexity, adversely affecting the clarity and maintainability of the code.
As it was explained above, the extensive and nested use of if-else statements, particularly when chaotically extended, leads to increased cognitive complexity, making the code harder to understand, maintain, and evolve. Therefore, the overuse of if-else structures, despite their necessity, can be counterproductive in complex programming scenarios.
Conditional offers a structured approach to managing conditional logic, addressing the inherent cognitive complexity of if-else statements. It provides a fluent interface that guides developers towards expressing conditional logic in a linear, more intuitive format. This approach effectively streamlines the if-else logic, making it more transparent and reducing the cognitive load associated with understanding and maintaining traditional conditional structures.
By simplifying the representation of conditional logic, Conditional helps in maintaining a cleaner and more organized codebase. It encourages writing concise and clear conditions, minimizing the chances of unwieldy and complex code patterns that often arise with standard if-else statements. This approach not only enhances the readability of the code but also eases the process of debugging and testing, leading to more maintainable software solutions.
-
Actions are executed in the order they were submitted:
public static void main(String[] args) { conditional(true) .onTrue(() -> System.out.println("First action executed")) .onTrue(() -> System.out.println("Second action executed")) .execute(); }
First action executed Second action executed
-
Bounding actions to
trueandfalsevalues can be intertwined:public static void main(String[] args) { conditional(true) .onTrue(() -> System.out.println("First action from TRUE")) .onFalse(() -> System.out.println("First action from FALSE")) .onTrue(() -> System.out.println("Second action from TRUE")) .execute(); }
First action from TRUE Second action from TRUE
-
Instances of
Conditionalcan be reused:public static void main(String[] args) { Conditional reusableConditional = conditional(true) .onTrue(() -> System.out.println("Hello, Universe!")); reusableConditional.execute(); reusableConditional.onTrue(() -> System.out.println("How are you?")); reusableConditional.execute(); }
Hello, Universe! Hello, Universe! How are you?
-
One can command to throw an exception if a given instance of
Conditionaldescribes a certain value:public static void main(String[] args) { conditional(9 % 2 == 0) .onTrue(() -> System.out.println("The number is even")) .onFalseThrow(new RuntimeException("The number must be even!")) .execute(); }
// throws a `RuntimeException`
Similar effect can be achieved via a slightly different API:
public static void main(String[] args) { conditional(9 % 2 == 0) .onTrue(() -> System.out.println("The number is even")) .onFalse(() -> { System.out.println("I'm going to throw an exception now..."); throw new RuntimeException("The number must be even!"); }) .execute(); }
I'm going to throw an exception now... // throws a `RuntimeException`
-
Actions can be described in multi-line manner:
public static void main(String[] args) { conditional(true) .onTrue(() -> { System.out.println("First line from true"); System.out.println("Second line from true"); }) .execute(); }
First line from true Second line from true
-
Execution can be performed a specified amount of cycles:
public static void main(String[] args) { conditional(true) .onTrue(() -> System.out.println("Hello, Universe!")) .onTrue(() -> System.out.println("How are you?")) .execute(2); // pass the number of cycles to execute }
Hello, Universe! How are you? Hello, Universe! How are you?
-
There are 4 static one-liners (see
isTrueOrThrow(…)andisFalseOrThrow(…)) that can be used to assure that a given condition has been met and throw an exception otherwise. For instance, one can ensure that a given condition is oftruevalue and command to throw aRuntimeExceptionif it’s not the case:public static void main(String[] args) { Conditional.isTrueOrThrow(10 % 2 == 0, (1) new RuntimeException("The number must be even!")); (2) }
-
Condition that is expected to be
true. If that’s the case, nothing happens. -
The exception that will be thrown if the specified condition isn’t met.
// nothing happens
-
-
Basic execution and get methods of
Conditional, i.e.execute(),execute(int cyclesToExecute)andget(Class<T> typeToGet), don’t specify anyExceptions in a method declaration in athrows…clause, although those methods are capable of throwing anException(the clause is omitted viaSneakyThrowson the underlying action). This allows to avoid enforcing of exception handling when basic execution and get methods ofConditionalare called.In cases, where enforcing of exception handling is, however, required, the overloaded
execute(…)andget(…)methods can be used. Those overloaded methods will behave the same way as their basic counterparts, the only difference being that their declarations have exception lists (throws…clause). Those lists are dynamically defined by the passed exception classes and can be used as a mean to enforce the discussed exception handling:public static void main(String[] args) { Conditional conditional = conditional(true) (1) .onTrue(() -> { throw new IOException(); }); conditional.execute(); (2) try { conditional.execute(IOException.class); (3) } catch (IOException exception) { log.error("Unable to read a file", exception); } String resultOne = conditional.get(String.class); (4) try { String resultTwo = conditional.get(String.class, IOException.class); (5) } catch (IOException exception) { log.error("Unable to read a file", exception); } }
-
Upon execution, this instance of
Conditionalalways throws anIOException, which is a subclass of anException. -
This basic execution method will not enforce exception handling, although it throws an
IOException, which is a subclass of anException. -
This overloaded execution method will enforce exception handling. Handling of
IOExceptionwill be enforced in this case, because it was passed as a parameter to the execution method. -
This basic get method will not enforce exception handling, although it throws an
IOException, which is a subclass of anException. -
This overloaded get method will enforce exception handling. Handling of
IOExceptionwill be enforced in this case, because it was passed as a parameter to the execution method.
-
Full API documentation of Conditional library can be found at this link: https://www.ciechanowiec.eu/conditional. The most important part is the API description of Conditional class itself: https://www.ciechanowiec.eu/conditional/eu/ciechanowiec/conditional/Conditional.html.
Conditional library is built as an OSGi bundle, therefore it can be used in OSGi environment. Among others, it can be used within Adobe Experience Manager (AEM).
The program is subject to MIT No Attribution License
Copyright © 2022-2024 Herman Ciechanowiec
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.
The Software is provided 'as is', without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the Software or the use or other dealings in the Software.