Remove Nat from documentation

crates/compiler/builtins/roc/Num.roc

@@ -192,9 +192,9 @@ interface Num
 ## a more specific type based on how they're used.
 ##
 ## For example, in `(1 + List.len myList)`, the `1` has the type `Num *` at first,
-## but because `List.len` returns a `Nat`, the `1` ends up changing from
-## `Num *` to the more specific `Nat`, and the expression as a whole
-## ends up having the type `Nat`.
+## but because `List.len` returns a `U64`, the `1` ends up changing from
+## `Num *` to the more specific `U64`, and the expression as a whole
+## ends up having the type `U64`.
 ##
 ## Sometimes number literals don't become more specific. For example,
 ## the `Num.toStr` function has the type `Num * -> Str`. This means that
@@ -216,7 +216,6 @@ interface Num
 ## * `215u8` is a `215` value of type [U8]
 ## * `76.4f32` is a `76.4` value of type [F32]
 ## * `123.45dec` is a `123.45` value of type [Dec]
-## * `12345nat` is a `12345` value of type [Nat]
 ##
 ## In practice, these are rarely needed. It's most common to write
 ## number literals without any suffix.
@@ -326,16 +325,6 @@ Num range := range
 ## | ` (over 340 undecillion)                            0` | [U128]| 16 Bytes |
 ## | ` 340_282_366_920_938_463_463_374_607_431_768_211_455` |       |          |
 ##
-## Roc also has one variable-size integer type: [Nat]. The size of [Nat] is equal
-## to the size of a memory address, which varies by system. For example, when
-## compiling for a 64-bit system, [Nat] is the same as [U64]. When compiling for a
-## 32-bit system, it's the same as [U32].
-##
-## A common use for [Nat] is to store the length ("len" for short) of a
-## collection like a [List]. 64-bit systems can represent longer
-## lists in memory than 32-bit systems, which is why the length of a list
-## is represented as a [Nat] in Roc.
-##
 ## If any operation would result in an [Int] that is either too big
 ## or too small to fit in that range (e.g. calling `Num.maxI32 + 1`),
 ## then the operation will *overflow*. When an overflow occurs, the program will crash.
@@ -443,18 +432,6 @@ U32 : Num (Integer Unsigned32)
 U16 : Num (Integer Unsigned16)
 U8 : Num (Integer Unsigned8)
 
-## A [natural number](https://en.wikipedia.org/wiki/Natural_number) represented
-## as a 64-bit unsigned integer on 64-bit systems, a 32-bit unsigned integer
-## on 32-bit systems, and so on.
-##
-## This system-specific size makes it useful for certain data structure
-## functions like [List.len], because the number of elements many data structures
-## can hold is also system-specific. For example, the maximum number of elements
-## a [List] can hold on a 64-bit system fits in a 64-bit unsigned integer, and
-## on a 32-bit system it fits in 32-bit unsigned integer. This makes [Nat] a
-## good fit for [List.len] regardless of system.
-Nat : Num (Integer Natural)
-
 Decimal := []
 Binary64 := []
 Binary32 := []
@@ -1446,20 +1423,6 @@ toU32 : Int * -> U32
 toU64 : Int * -> U64
 toU128 : Int * -> U128
 
-## Converts an [Int] to a [Nat]. If the given number doesn't fit in [Nat], it will be truncated!
-## Since [Nat] has a different maximum number depending on the system you're building
-## for, this may give a different answer on different systems.
-##
-## For example, on a 32-bit system, calling `Num.toNat 9_000_000_000` on a 32-bit
-## system will return `Num.maxU32` instead of 9 billion, because 9 billion is
-## higher than `Num.maxU32` and will not fit in a [Nat] on a 32-bit system.
-##
-## However, calling `Num.toNat 9_000_000_000` on a 64-bit system will return
-## the [Nat] value of 9_000_000_000. This is because on a 64-bit system, [Nat] can
-## hold up to `Num.maxU64`, and 9_000_000_000 is lower than `Num.maxU64`.
-##
-## To convert a [Frac] to a [Nat], first call either `Num.round`, `Num.ceil`, or `Num.floor`
-## on it, then call this on the resulting [Int].
 toNat : Int * -> Nat
 
 ## Converts a [Num] to an [F32]. If the given number can't be precisely represented in an [F32],