Is there a keyword or operator for "nor"?

Question

Is there an operator equivalent of nor? For example, my favorite color is neither green nor blue.

And the code would be equivalent to:

// example one
if (color!="green" && color!="blue") { 

}

// example two
if (x nor y) {
    // x is false and y is false
}

Answer 1

Although mainstream languages do not have dedicated NOR and NAND operators, some lesser-known languages (for example, some "golfing" languages) do. For example, APL has ⍱ and ⍲ for NOR and NAND, respectively.

Another class of examples can be found in hardware design languages such as VHDL, Verilog, etc. NAND and NOR gates are quite useful in hardware design due to usually being cheaper (requiring fewer transistors) than the equivalent circuit made from AND/OR/NOT gates, which is one of the reasons hardware design languages tend to include them; another reason is that they can be useful for certain bit-fiddling tricks.

Answer 2

No, there is no nor operator in any high level mainstream programming language.

Why ?

Mainly because it is difficult to read:

• it requires the mental combination of several operators ( "and not", or in a more literary style : "further negative", "each untrue")
• it implies an implicit not on the first operand, but the reader only understand this afterwards
• it is different from human languages, which use an explicit negation on the first operand, such as "neither x nor y", "nor x nor y". So a reader might confuse (x nor y) with (x and not y) instead of ((not x) and (not y))
• some readers are confused with the apparent or semantic which doesn't apply

But it's so common in hardware...

nor is an elementary hardware gate that can be used to make all the other logical gates. So one could argue that all the other logical operators are combinations and nor is the simplest elementary logical operator.

However, what's true for the hardware is not necessarily true to the humans. And despite it's popularity at hardware level, some mainstream CPUs do not even offer a NOR in their assembler instruction set (e.g. x86).

Alternatives

Readability matters. And sometimes it can be improved by other means.

Use of existing operators

For example:

if x not in [1,2]    // use of 'in' or 'not in' operator instead of x!=1 and x!=2

Ordering of conditions

if x==1 or x==2 
     action A
else 
     action B  

instead of

if x!=1 and x!=2 
    action B
else 
    action A

Use of until loop

Some languages also offer loop instructions that allow to express conditions either with while or with until, letting you choose the more "positive" way. These instructions are for example until c do ... in ruby, do until c ... in vb, or repeat ... until c in pascal and its descendants.

For example:

Until (x==1 or x==2) do
     ...

is equivalent to:

While (x!=1 and x!=2)
    ...

Make a function

Now if you still prefer the nor syntax, you could define a function, but only if you don't expect a shortcut to happen:

If ( nor(x,y) )   // attention, x and y will always be evaluated
    ...  

There is a readability advantage of the function over the operator, because the reader immediately understands that the negation applies to all arguments. In some languages you can define a function with a variable number of arguments.

Answer 3

@KilianFoth's comment on the question is spot on.

You can synthesize nor from not and or:

if (x nor y)

is exactly the same as

if (not (x or y))

Introducing nor as a separate operator would introduce redundancies to the language, which are neither needed, nor wanted (or - which are not needed and not wanted).

Similarly, I am not aware of any language having a nand operator - probably because it can be synthesized from not and and operators.

You could, in theory, create a language with only nand or only nor operators. All of and, or, and not could then by synthesied from them. The only problem is that this would be ridiculously unwieldy. For examples, see NOR logic and NAND logic on Wikipedia.

Answer 4

Yes, APL and some of its dialects have nor (and nand). In APL, nor is denoted ⍱ (since ∨ is or and ~ is not):

∇ result←ExampleOne color
  :If (color≡'green')⍱(color≡'blue')
      result←'warm'
  :Else
      result←'cold'
  :EndIf
∇

∇ result←ExampleTwo(x y)
  :If x⍱y
      result←'x is false and y is false'
  :Else
      result←'at least one of them is true'
  :EndIf
∇

Try it online!

Answer 5

This answer is from the assembler language for a computer made in the mid 1960s. That's pretty obscure, but in some respects it addresses your question.

DEC (Digital Equipment Corporation) launched the PDP-6 computer in the mid 1960s. This machine had a total of 64 instructions that were boolean operations on two operands (including some degenerate cases). These 64 instructions were really 16 operators with 4 variants in each operator.

Two of the operators, ANDCB and ORCB implemented NOR and NAND respectively (unless I am mixed up on the double negative logic). You can see the opcode table. The opcode table is actually for the PDP-10 computer, a successor to the PDP-6.

If you look at the numerical instruction in binary, it gets more interesting. It turns out that for all the opcodes in the range 400-477 (octal), four bits in the instruction itself provide a four bit truth table for 16 possible boolean operators. Some of these operators ignore one or both of the inputs. For example SETZ and SETO ignore both of the inputs.

The designers of the PDP-6 exploited this fact to implement all these instructions with less logic than it would have taken to implement only some of them. Some of these instructions appeared rarely, if ever, in assembly language code. But they were all there.

So ANDCB is the equivalent of NOR. (again, unless I got my logic backwards, in which case ORCB is the equivalent).

Answer 6

Perl has the unless keyword that lets you invert conditionals:

unless ($color eq 'green' or $color eq 'blue') {
    # code
}

While not NOR operator, you can express your intent in a similar way.

Answer 7

The nor operator as you described it would not be repeatable, which is bound to lead to lots of difficult to spot bugs.

Your "Example 2" is essentially this:

if (false nor false) {
becomes
if (true) {

But try that again with three variables and see what happens:

if (false nor false nor false) {
becomes
if ((false nor false) nor false) {
becomes
if (true nor false) {
becomes
if (false) {