remove commented out builtin code

crates/compiler/builtins/roc/Num.roc

@@ -1264,164 +1264,3 @@ toU128Checked : Int * -> Result U128 [OutOfBounds]
 toNatChecked : Int * -> Result Nat [OutOfBounds]
 toF32Checked : Num * -> Result F32 [OutOfBounds]
 toF64Checked : Num * -> Result F64 [OutOfBounds]
-
-# Special Floating-Point operations
-## When given a [F64] or [F32] value, returns `Bool.false` if that value is
-## [*NaN*](Num.isNaN), ∞ or -∞, and `Bool.true` otherwise.
-##
-## Always returns `Bool.true` when given a [Dec].
-##
-## This is the opposite of #isInfinite, except when given [*NaN*](Num.isNaN). Both
-## #isFinite and #isInfinite return `Bool.false` for [*NaN*](Num.isNaN).
-# isFinite : Frac * -> Bool
-## When given a [F64] or [F32] value, returns `Bool.true` if that value is either
-## ∞ or -∞, and `Bool.false` otherwise.
-##
-## Always returns `Bool.false` when given a [Dec].
-##
-## This is the opposite of #isFinite, except when given [*NaN*](Num.isNaN). Both
-## #isFinite and #isInfinite return `Bool.false` for [*NaN*](Num.isNaN).
-# isInfinite : Frac * -> Bool
-## When given a [F64] or [F32] value, returns `Bool.true` if that value is
-## *NaN* ([not a number](https://en.wikipedia.org/wiki/NaN)), and `Bool.false` otherwise.
-##
-## Always returns `Bool.false` when given a [Dec].
-## ```
-##  Num.isNaN 12.3
-##
-##  Num.isNaN (Num.pow -1 0.5)
-## ```
-## *NaN* is unusual from other numberic values in that:
-## * *NaN* is not equal to any other number, even itself. [Bool.isEq] always returns `Bool.false` if either argument is *NaN*.
-## * *NaN* has no ordering, so [isLt], [isLte], [isGt], and [isGte] always return `Bool.false` if either argument is *NaN*.
-##
-## These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754)
-## floating point standard. Because almost all modern processors are built to
-## this standard, deviating from these rules has a significant performance
-## cost! Since the most common reason to choose [F64] or [F32] over [Dec] is
-## access to hardware-accelerated performance, Roc follows these rules exactly.
-##
-## Note that you should never put a *NaN* into a [Set], or use it as the key in
-## a [Dict]. The result is entries that can never be removed from those
-## collections! See the documentation for [Set.insert] and [Dict.insert] for details.
-# isNaN : Frac * -> Bool
-## Returns the higher of two numbers.
-##
-## If either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*
-## is [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)
-# max : Num a, Num a -> Num a
-## Returns the lower of two numbers.
-##
-## If either argument is [*NaN*](Num.isNaN), returns `Bool.false` no matter what. (*NaN*
-## is [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).)
-# min : Num a, Num a -> Num a
-# Branchless implementation that works for all numeric types:
-#
-# let is_lt = arg1 < arg2;
-# let is_eq = arg1 == arg2;
-# return (is_lt as i8 - is_eq as i8) + 1;
-#
-# 1, 1 -> (0 - 1) + 1 == 0 # Eq
-# 5, 1 -> (0 - 0) + 1 == 1 # Gt
-# 1, 5 -> (1 - 0) + 1 == 2 # Lt
-## Returns `Lt` if the first number is less than the second, `Gt` if
-## the first is greater than the second, and `Eq` if they're equal.
-##
-## Although this can be passed to `List.sort`, you'll get better performance
-## by using `List.sortAsc` or `List.sortDesc` instead.
-# compare : Num a, Num a -> [Lt, Eq, Gt]
-## [Endianness](https://en.wikipedia.org/wiki/Endianness)
-# Endi : [Big, Little, Native]
-## The `Endi` argument does not matter for [U8] and [I8], since they have
-## only one byte.
-# toBytes : Num *, Endi -> List U8
-## when Num.parseBytes bytes Big is
-##     Ok { val: f64, rest } -> ...
-##     Err (ExpectedNum (Frac Binary64)) -> ...
-# parseBytes : List U8, Endi -> Result { val : Num a, rest : List U8 } [ExpectedNum a]*
-## when Num.fromBytes bytes Big is
-##     Ok f64 -> ...
-##     Err (ExpectedNum (Frac Binary64)) -> ...
-# fromBytes : List U8, Endi -> Result (Num a) [ExpectedNum a]*
-# Bit shifts
-## [Logical bit shift](https://en.wikipedia.org/wiki/Bitwise_operation#Logical_shift) left.
-##
-## `a << b` is shorthand for `Num.shl a b`.
-# shl : Int a, Int a -> Int a
-## [Arithmetic bit shift](https://en.wikipedia.org/wiki/Bitwise_operation#Arithmetic_shift) left.
-##
-## This is called `shlWrap` because any bits shifted
-## off the beginning of the number will be wrapped around to
-## the end. (In contrast, #shl replaces discarded bits with zeroes.)
-# shlWrap : Int a, Int a -> Int a
-## [Logical bit shift](https://en.wikipedia.org/wiki/Bitwise_operation#Logical_shift) right.
-##
-## `a >> b` is shorthand for `Num.shr a b`.
-# shr : Int a, Int a -> Int a
-## [Arithmetic bit shift](https://en.wikipedia.org/wiki/Bitwise_operation#Arithmetic_shift) right.
-##
-## This is called `shrWrap` because any bits shifted
-## off the end of the number will be wrapped around to
-## the beginning. (In contrast, #shr replaces discarded bits with zeroes.)
-# shrWrap : Int a, Int a -> Int a
-# ## Convert a number into a [Str], formatted with the given options.
-# ##
-# ## Default options:
-# ## * `base: Decimal`
-# ## * `notation: Standard`
-# ## * `decimalMark: HideForIntegers "."`
-# ## * `decimalDigits: { min: 0, max: All }`
-# ## * `minIntDigits: 1`
-# ## * `wholeSep: { mark: ",", places: 3 }`
-# ##
-# ## ## Options
-# ##
-# ##
-# ## ### decimalMark
-# ##
-# ## * `AlwaysShow` always shows the decimal mark, no matter what.
-# ## * `HideForIntegers` hides the decimal mark if all the numbers after the decimal mark are 0.
-# ##
-# ## The [Str] included in either of these represents the mark itself.
-# ##
-# ## ### `decimalDigits
-# ##
-# ## With 0 decimal digits, the decimal mark will still be rendered if
-# ## `decimalMark` is set to `AlwaysShow`.
-# ##
-# ## If `max` is less than `min`, then first the number will be truncated to `max`
-# ## digits, and then zeroes will be added afterwards until it reaches `min` digits.
-# ##
-# ##     Num.format 1.23 { decPlaces: 0, decPointVis: AlwaysShow }
-# ##
-# ## ### minIntDigits
-# ##
-# ## If the integer portion of number is fewer than this many digits, zeroes will
-# ## be added in front of it until there are at least `minWholeDigits` digits.
-# ##
-# ## If this is set to zero, then numbers less than 1 will begin with `"."`
-# ## rather than `"0."`.
-# ##
-# ## ### wholeSep
-# ##
-# ## Examples:
-# ##
-# ## In some countries (e.g. USA and UK), a comma is used to separate thousands:
-# ##     Num.format 1_000_000 { pf: Decimal, wholeSep: { mark: ",", places: 3 } }
-# ##
-# ## Sometimes when rendering bits, it's nice to group them into groups of 4:
-# ##     Num.format 1_000_000 { pf: Binary, wholeSep: { mark: " ", places: 4 } }
-# ##
-# ## It's also common to render hexadecimal in groups of 2:
-# ##     Num.format 1_000_000 { pf: Hexadecimal, wholeSep: { mark: " ", places: 2 } }
-# format :
-#     Num *,
-#     {
-#         base ? [Decimal, Hexadecimal, Octal, Binary],
-#         notation ? [Standard, Scientific],
-#         decimalMark ? [AlwaysShow Str, HideForIntegers],
-#         decimalDigits ? { min : U16, max : [All, Trunc U16, Round U16, Floor U16, Ceil U16] },
-#         minWholeDigits ? U16,
-#         wholeSep ? { mark : Str, places : U64 }
-#     }
-#     -> Str