Reducing Cognitive Complexity of Single-Responsibility "Arrow-Code"

Question

Prompted by Sonar, I am looking to reduce the complexity of a function (one that some might call arrow code). I am loosely familiar with some of the principles of reducing arrow code complexity (flattening, eager returns, guard statements instead of affirmative condition checks), but I doubt that this particular code is satisfied by any of those.

The function takes three parameters and returns a string. If the first parameter does not meet the criteria for if/else-if outer block, the function returns a default string (the initial string assignment). For the sake of brevity, I think we can safely assume the function takes only 2 parameters.

Pseudocode

String getMyString(String parameter1, String parameter2) {
    String myString = "STRING_A.Y"
    if (parameter1 == optionA) {
        if (parameter2 == optionX) {
            myString = "STRING_A.X"
        } else {
            myString = "STRING_A.Y"
        }
    } else if (parameter1 == optionB) {
        if (parameter2 == optionX) {
            myString = "STRING_B.X"
        } else {
            myString = "STRING_B.Y"
        }
    }
    return myString
}  

In the case of three parameters, we are looking at 8 possible outputs. The only way I see to "reduce" complexity would be to turn this into a switch statement, but I personally find that the code would be less readable (particularly when more parameters are introduced). I don't see a meaningful way to separate this code into smaller functions. I don't see a way to add guard statements that might reduce the degree of nesting here. Is a switch statement the best alternative?

Answer 1

According to your own comment, you do not build the result based on parameters but you rather mapped specific parameter combinations to some constant. So why not use some ParameterTuple=>Constant map?

Add some default in case there is no match. Actual implementation is language specific, but more parameter would only result in additional map entries, without further complexity.

Answer 2

If you are attempting to optimize for readability and not optimizing for cleverness or performance or brevity, this is the way I would write it.

String getMyString(String parameter1, String parameter2) {
    if (parameter1 == optionA && parameter2 == optionX) return "STRING_A.X";
    if (parameter1 == optionA && parameter2 != optionX) return "STRING_A.Y";
    if (parameter1 == optionB && parameter2 == optionX) return "STRING_B.X";
    if (parameter1 == optionB && parameter2 != optionX) return "STRING_B.Y";
    return "STRING_A.Y";
}

This eliminates any confusion and many of the common logic bugs. The conditions are all mutually exclusive and free of sequential dependency; they can be put in any order, and new ones can be added in between, or conditions removed, with little risk of impacting the other conditions. Also, the default value is clearly expressed as a catch-all at the end.

Answer 3

This solves the problem in three lines, and looks more readable to me as well.

String part1 = (parameter1 == optionA ? "String_A" : "String_B";
String part2 = (parameter2 == optionX ? ".X" : ".Y";
return part1 + part2;