types-grammar, ch2: finishing ch2 draft

Author: getify

types-grammar/ch1.md

@@ -855,6 +855,10 @@ You may wonder why we'd ever need such a thing as `-0`. It can be useful when us
 
 Without having a signed zero value, you couldn't tell which direction such an item was pointing at the moment it came to rest.
 
+| NOTE: |
+| :--- |
+| While JS defines a signed zero in the `number` type, there is no corresponding signed zero in the `bigint` number type. As such, `-0n` is just interpreted as `0n`, and the two are indistinguishable. |
+
 ### Invalid Number
 
 Mathematical operations can sometimes produce an invalid result. For example:

types-grammar/ch2.md

@@ -941,6 +941,12 @@ myAge = 41. + 1.;
 myAge;                          // 42
 ```
 
+Values of `bigint` type cannot have decimals, so the parsing is unambiguous that a `.` after a literal (with the trailing `n`) is always a property access:
+
+```js
+42n.toString();                 // 42
+```
+
 ### Static `Number` Properties
 
 * `Number.EPSILON`: The smallest value possible between `1` and the next highest number
@@ -988,6 +994,47 @@ Unlike `Number`, which is also the `Number(..)` function (for number coercion),
 | :--- |
 | One peculiar member of the `Math` namespace is `Math.random()`, for producing a random floating point value between `0` and `1.0`. It's unusual to consider random number generation -- a task that's inherently stateful/side-effect'ing -- as a mathematical operation. It's also long been a footgun security-wise, as the pseudo-random number generator (PRNG) that JS uses is *not* secure (can be predicted) from a cryptography perspective. The web platform stepped in several years ago with the safer `crypto.getRandomValues(..)` API (based on a better PRNG), which fills a typed-array with random bits that can be interpreted as one or more integers (of type-specified maximum magnitude). Using `Math.random()` is universally discouraged now. |
 
+### BigInts and Numbers Don't Mix
+
+As we covered in Chapter 1, values of `number` type and `bigint` type cannot mix in the same operations. That can trip you up even if you're doing a simple increment of the value (like in a loop):
+
+```js
+myAge = 42n;
+
+myAge + 1;                  // TypeError thrown!
+myAge += 1;                 // TypeError thrown!
+
+myAge + 1n;                 // 43n
+myAge += 1n;                // 43n
+
+myAge++;
+myAge;                      // 44n
+```
+
+As such, if you're using both `number` and `bigint` values in your programs, you'll need to manually coerce one value-type to the other somewhat regularly. The `BigInt(..)` function (no `new` keyword) can coerce a `number` value to `bigint`. Vice versa, to go the other direction from `bigint` to `number`, use the `Number(..)` function (again, no `new` keyword):
+
+```js
+BigInt(42);                 // 42n
+
+Number(42n);                // 42
+```
+
+Keep in mind though: coercing between these types has some risk:
+
+```js
+BigInt(4.2);                // RangeError thrown!
+BigInt(NaN);                // RangeError thrown!
+BigInt(Infinity);           // RangeError thrown!
+
+Number(2n ** 1024n);        // Infinity
+```
+
+## Primitives Are Foundational
+
+Over the last two chapters, we've dug deep into how primitive values behave in JS. I bet more than a few readers were, like me, ready to skip over these topics. But now, hopefully, you see the importance of understanding these concepts.
+
+The story doesn't end here, though. Far from it! In the next chapter, we'll turn our attention to understanding JS's object types (objects, arrays, etc).
+
 [^TwitterUnicode]: "New update to the Twitter-Text library: Emoji character count"; Andy Piper; Oct 2018; https://twittercommunity.com/t/new-update-to-the-twitter-text-library-emoji-character-count/114607 ; Accessed July 2022
 
 [^INTLAPI]: ECMAScript 2022 Internationalization API Specification; https://402.ecma-international.org/9.0/ ; Accessed August 2022

types-grammar/toc.md

@@ -22,4 +22,4 @@
     * Primitive Assignments
     * String Behaviors
     * Number Behaviors
-    * TODO
+    * Primitives Are Foundational