I'm interpreting your question to be: "Does Mathematica use 'which' where other languages use 'then', and does Mathematica use 'switch' where other languages use 'else'?"

The answer is "no".

Mathematica has an If[...] form, and it is analogous to the if {...} else {...} branching structure of procedural languages like Java.

Mathematica has a Swich[...] form, and it is analogous to the switch {case ...} branching structure of procedural languages like Java.

Mathematica has a Which[...] form, and I think most procedural languages like Java have no analog to it. It is basically the same as cond from Lisp.

Thanks. I'm pretty sure I tried it at first and it didn't work!!!

In fact I think the core of the problem is how to get the expression "a>b" dynamically evaluated in this example

{Slider[Dynamic[a]], Dynamic[a]} {Slider[Dynamic[b]], Dynamic[b]} Dynamic[a]> Dynamic[b]

Alain,

Let's walk through the case of fWhich[2,1] (this isn't valid Mathematica syntax, I'm just trying to step through what happens conceptually):

fWhich[2,1]
--> aa = 3 + w  &&  bb = 3 - w
--> r1 = Which[aa == bb, AB, aa > bb, AA, bb > aa, BB]
--> r1 = Which[3 + w == 3 - w, AB, aa > bb, AA, bb > aa, BB]

This Which expression cannot be resolved, because Which expects all of the "test" expressions to evaluate to True or False. Since 3 + w == 3 - w cannot be resolved to True of False, the Which expression gets assigned to r1 with no further evaluation of its arguments. Same thing happens with r2 and r3. So, we end up with

fWhich[2,1] being equal to
{3 + w, 3 - w, Which[3 + w == 3 - w, AB, aa > bb, AA, bb > aa, BB], 
 Which[3 + w > 3 - w, AA, aa == bb, AB, bb > aa, BB], 
 Which[3 - w > 3 + w, BB, aa > bb, AA, aa == bb, AB]}

That whole expression is what you get when you evaluate fWhich[2,1]. Then you replace the w with, say -1. Let's look at the first Which expression (the one assigned to r1).

Which[3 + w == 3 - w, AB, aa > bb, AA, bb > aa, BB]
--> Which[3 + -1 == 3 - -1, AB, aa > bb, AA, bb > aa, BB]
--> Which[2 == 4, AB, aa > bb, AA, bb > aa, BB]
--> Which[False, AB, aa > bb, AA, bb > aa, BB]
--> Which[aa > bb, AA, bb > aa, BB]

And at that point, no further evaluation of Which can be completed. This is exactly what you now see in your output, that partially simplified Which expression. Compare this to fWhich[2,0]. In that case, the first expression, after substituting for the w, evaluates to True, and so it can resolve to BB, which is, again, exactly what you see in your output.

You seem to be expecting that all of the parts of Which would be partially expanded into expressions using the values of u and v instead of just the aa and bb, but Which has the HoldAll attribute, so it keeps those unevaluated until it needs them. Since it didn't need any of them beyond the first one, you're seeing the aa and bb "leak" out. They were only defined within the scope of the Block, so now they are just raw symbols with no definition.

Unless you can provide a better reason than w being a "mere parameter", what you really want to do here add is w to the input arguments for fWhich. You can "curry" your function if that makes it clearer for you:

fWhich[u_,v_,w_]:=...

or

fWhich[u_, v_][w_]:=...

The situation with your fIf function is slightly different, because If will still evaluate if the conditional is not True or False. In fact, you can provide a fourth input to be returned in the case that the conditional is neither True or False. Maybe this behavior is more of what you are expecting. I can work through that approach if you wish.

Thanks for your kind answer. but you can easily imagine this is a very simple example and the many "w" are mere parameters I would use only at the moment of evaluation. and I still don't understand why the expression in Which is resolved only when the first case is true, something like the //. only works on the first part of the expression.