Why were the /\ (min) and the \/ (max) operators abandoned in the C language?

Question

In the UNIX V7 version of the C language (but not yet in the V6 version), there were the /\ (min) and the \/ (max) operators. In the source of the scanner part of the compiler,

case BSLASH:
    if (subseq('/', 0, 1))
        return(MAX);
    goto unkn;

case DIVIDE:
    if (subseq('\\', 0, 1))
        return(MIN);
...

However, attempting to use them reveals that the corresponding part in the code generator is missing. Trying to compile

foo(a, b) { return a \/ b; } 

results in

1: No code table for op: \/

Granted, using the otherwise "magic" backslash character for those operators was not a good choice, but why abandon things half-way? I don't remember any mention of them in the literature. What's the story behind them? (Ken Thompson was reported — on another mailing list where I linked to this question — as saying that the piece of code is news to him.)

In the Xinu7 source dated 1986, the MIN and MAX operators in the parser are still there, and the code generation table still lacks the implementation.

In the "PDP-11 3+2" source, dated 1983, they are also there.

Answer 1

(speculation, but I'm pretty confident in it) Assuming \/ and /\ were actually used in early C to be max and min, someone probably quickly realized how totally stupid that symbology is. They look like the long-accepted boolean operators for OR (∨) and AND (∧). Having something you've been taught since high school means AND now stands for min in C would have been an extremely bad idea. It is equivalent to a computer language designer deciding that, in their language, the plus symbol (+) should mean divide (÷).

Answer 2

Assuming these operators were part of "original C" (I don't think so, see some comments):

The main reason why these weren't followed up would probably be: C being what it is - a close-to-the-machine language - an operator in C would need to be aligned with at least some closely related machine instruction - Most of the C operators are.

I am not aware of any wide-spread architecture that had a machine instruction that produced the bigger (or smaller) of two values. Without that machine instruction, a compiler would have had to revert to compiler intrinsics, something that wasn't known as a concept back then (for good reasons).

I have the strong feeling that these operators were some sort of hack that was introduced (or partially introduced) to port C to some architecture that actually had such instructions, and then forgotten in the code. This text states, which might be a hint:

Also during this period [Unix kernel programmed in C for the first time], the compiler was retargeted to other nearby machines, particularly the Honeywell 635 and IBM 360/370;