Multiple Argument Switch Statement - language-agnostic

Question

So I was taking a Computer Science test today, and I had to write out a large number of consecutive if statements. All of them had the same basic arguments, just the conditions were different. The whole thing made me wonder if somewhere out there was a multiple argument switch statement. An example of what I'm thinking of is this:
int i = 7;
switch(i > 4, i < 10) {
case T, T:
return "between 4 and 10";
case T, F:
return "greater than 10";
case F, T:
return "less than 4";
case F, F:
return "your computer's thinking is very odd";
}
In this case, the arguments are i > 4 and i > 10, and the T and F are whether the argument is true or not.
I know this example can be easily done other ways, but I'm just trying to show its use. And what if there were 4 arguments, that would be something like 20 if statements each requiring you to retype the conditions.
So my question is, is there any language that does this? Or is it planned for a future language? Or does an even better method exist?

Answer 1

It's hard to say that "no language does this" because there almost certainly is someone working on an experimental language or two that does. However, most procedural languages don't have this kind of feature.
In your example, I think you mean the T, F, etc. to mean "the first expression evaluates to True and the second evaluates to False" (that is, the , is logical AND). This is reminiscent of some decision table languages, where the processing involves finding the first row of a decision table that is satisfied and executing that row's action. Other than that, I don't know of any language that has anything like this.

Answer 2

At least in languages that allow conversion from bool to int, you can handle this pretty easily. You basically just convert the two booleans into a bit-mapped integer value. Since you have two booleans, you can use one directly as bit 0 of your result, and the other multiplied by two as the second bit of your result.
int i = 7;
int range = (i>4) | (i<10)*2;
switch(range) {
case 3: return "between 4 and 10";
case 2: return "greater than 10";
case 1: return "less than 4";
case 0: return "your computer's thinking is very odd";
}

Answer 3

In Mathematica:
Switch[{i > 4, i < 10},
{True, True}, "between 4 and 10",
{True, False}, "greater than 10",
{False, True}, "less than 4",
{False, False}, "your computer's thinking is very odd"
]
Of course, this prints that 4 is less than 4, and 10 is greater than 10, but that's in your pseudocode.
For this specific case one might better write:
Which[
i < 4, "less than 4",
4 <= i <= 10, "between 4 and 10",
i > 10, "greater than 10",
True, "your computer's thinking is very odd"
]

Answer 4

in Python:
i = 7
test = (i > 4, i < 10)
print test
if test == (True, True):
print "between 4 and 10"
elif test == (True, False):
print "greater than 10"
elif test == (False, True):
print "less than 4"
elif test == (False, False):
print "your computer's thinking is very odd"

Answer 5

You can do almost exactly this many languages already, without any special language support. For example, in ruby:
i = 7
case ([i > 4, i < 10])
when [true, true]:
puts "between 4 and 10"
when [true, false]:
puts "greater than 10"
...
end
Or in groovy:
i = 7
switch([i > 4, i < 10]) {
case [[true, true]]:
println "between 4 and 10"
break;
case [[true, false]]:
println "greater than 10"
break;
...
}

Answer 6

I agree with Ted of course - it's hard to say what languages might exist. But your logic can be handled in many.
Your switch just translates first to an if (something like if ((i > 4) && (i < 10)) in many languages).
The switch cases could be modeled as function return values, expressed in some domain-specific way, again, in many languages, even most.