Option C. The value NaN compares unequal to every value, even itself. This breaks one of the rules of what equality even means (that every value must be equal to itself, the "reflexivity" axiom). It is for this reason (among others, ~~equality~~ "partial" equivalence between values of different types? 🤮) Rust needed to have PartialEq. See IEEE 754 for more details.
Why typeof null is "object"? Because it is defined so: https://tc39.es/ecma262/multipage/ecmascript-language-expressions.html#sec-typeof-operator
5. If
valisnull, return"object".
As for the rationale behind the choice, it might have something to do with "Prototypal inherience" the language has. https://tc39.es/ecma262/multipage/overview.html#sec-objects
Every object created by a constructor has an implicit reference (called the object's prototype) to the value of its constructor's "prototype" property. Furthermore, a prototype may have a non-null implicit reference to its prototype, and so on; this is called the prototype chain.
We can understand this to mean that prototype chains are null terminated ;)
For example:
> Object.getPrototypeOf({}) === Object.prototype
true
> Object.getPrototypeOf(Object.getPrototypeOf({}))
null
> Object.getPrototypeOf(null) TypeError: not an object
Uhh...
Now, let's go to some abstract algebra. All good (closed) binary operations we deal with have an identity or neutral value. For example: addition has 0, multiplication has 1, boolean and has true, boolean or or xor has false. Performing these operations with the neutral value does not change the other operand: for example, x + 0 == x, a * 1 == a, true && b == b and so on. If you admit min and max as operators, you can see why ∞ and -∞ are the neutral values, respectively: min(∞, x) == x and max(-∞, y) == y for every (real) value of x and y. Observe how Array.prototype.reduce works (with its second argument) for inspiration on why and how all this matters: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce
For mathematicians: closed, because the operators are maps S × S →S, to exclude <, > etc. as they map to Bool. Oh, they are relations, bla bla .... real numbers, we don't want to deal with other total orders here, there should be some way to call orders that have both top and bottom values, complex numbers don't have orders (usual ones, are there unusual ones?), bla bla bla
As for the last one, sigh.. https://tc39.es/ecma262/multipage/abstract-operations.html#sec-islooselyequal
Oh, that !s in there aren't boolean not.. they are.. (looks it up) argh, read it yourself https://tc39.es/ecma262/multipage/notational-conventions.html#sec-returnifabrupt-shorthands
