Fix and improve numeric-literals.md

Author: ShapelessCat

docs/docs/reference/changed-features/numeric-literals.md

@@ -24,47 +24,54 @@ how large they can be.
 
 The meaning of a numeric literal is determined as follows:
 
- - If the literal ends with `l` or `L`, it is a `Long` integer (and must fit
-   in its legal range).
- - If the literal ends with `f` or `F`, it is a single precision floating point number of type `Float`.
- - If the literal ends with `d` or `D`, it is a double precision floating point number of type `Double`.
+- If the literal ends with `l` or `L`, it is a `Long` integer (and must fit in its legal range).
+- If the literal ends with `f` or `F`, it is a single precision floating point number of type `Float`.
+- If the literal ends with `d` or `D`, it is a double precision floating point number of type `Double`.
 
 In each of these cases the conversion to a number is exactly as in Scala 2 or in Java. If a numeric literal does _not_ end in one of these suffixes, its meaning is determined by the expected type:
 
- 1. If the expected type is `Int`, `Long`, `Float`, or `Double`, the literal is
+1. If the expected type is `Int`, `Long`, `Float`, or `Double`, the literal is
    treated as a standard literal of that type.
- 2. If the expected type is a fully defined type `T` that has a given instance of type
+2. If the expected type is a fully defined type `T` that has a given instance of type
    `scala.util.FromDigits[T]`, the literal is converted to a value of type `T` by passing it as an argument to
    the `fromDigits` method of that instance (more details below).
- 3. Otherwise, the literal is treated as a `Double` literal (if it has a decimal point or an
+3. Otherwise, the literal is treated as a `Double` literal (if it has a decimal point or an
    exponent), or as an `Int` literal (if not). (This last possibility is again as in Scala 2 or Java.)
 
 With these rules, the definition
+
 ```scala
 val x: Long = -10_000_000_000
 ```
+
 is legal by rule (1), since the expected type is `Long`. The definitions
+
 ```scala
 val y: BigInt = 0x123_abc_789_def_345_678_901
 val z: BigDecimal = 111222333444.55
 ```
+
 are legal by rule (2), since both `BigInt` and `BigDecimal` have `FromDigits` instances
 (which implement the `FromDigits` subclasses `FromDigits.WithRadix` and `FromDigits.Decimal`, respectively).
 On the other hand,
+
 ```scala
 val x = -10_000_000_000
 ```
+
 gives a type error, since without an expected type `-10_000_000_000` is treated by rule (3) as an `Int` literal, but it is too large for that type.
 
 ### The FromDigits Trait
 
 To allow numeric literals, a type simply has to define a `given` instance of the
 `scala.util.FromDigits` type class, or one of its subclasses. `FromDigits` is defined
 as follows:
+
 ```scala
 trait FromDigits[T]:
    def fromDigits(digits: String): T
 ```
+
 Implementations of the `fromDigits` convert strings of digits to the values of the
 implementation type `T`.
 The `digits` string consists of digits between `0` and `9`, possibly preceded by a
@@ -74,6 +81,7 @@ the string is passed to `fromDigits`.
 The companion object `FromDigits` also defines subclasses of `FromDigits` for
 whole numbers with a given radix, for numbers with a decimal point, and for
 numbers that can have both a decimal point and an exponent:
+
 ```scala
 object FromDigits:
 
@@ -95,6 +103,7 @@ object FromDigits:
     */
    trait Floating[T] extends Decimal[T]
 ```
+
 A user-defined number type can implement one of those, which signals to the compiler
 that hexadecimal numbers, decimal points, or exponents are also accepted in literals
 for this type.
@@ -104,6 +113,7 @@ for this type.
 `FromDigits` implementations can signal errors by throwing exceptions of some subtype
 of `FromDigitsException`. `FromDigitsException` is defined with three subclasses in the
 `FromDigits` object as follows:
+
 ```scala
 abstract class FromDigitsException(msg: String) extends NumberFormatException(msg)
 
@@ -115,17 +125,22 @@ class MalformedNumber(msg: String = "malformed number literal") extends FromDigi
 ### Example
 
 As a fully worked out example, here is an implementation of a new numeric class, `BigFloat`, that accepts numeric literals. `BigFloat` is defined in terms of a `BigInt` mantissa and an `Int` exponent:
+
 ```scala
 case class BigFloat(mantissa: BigInt, exponent: Int):
    override def toString = s"${mantissa}e${exponent}"
 ```
+
 `BigFloat` literals can have a decimal point as well as an exponent. E.g. the following expression
 should produce the `BigFloat` number `BigFloat(-123, 997)`:
+
 ```scala
 -0.123E+1000: BigFloat
 ```
+
 The companion object of `BigFloat` defines an `apply` constructor method to construct a `BigFloat`
 from a `digits` string. Here is a possible implementation:
+
 ```scala
 object BigFloat:
    import scala.util.FromDigits
@@ -149,13 +164,16 @@ object BigFloat:
                (intPart, givenExponent)
       BigFloat(BigInt(intPart), exponent)
 ```
+
 To accept `BigFloat` literals, all that's needed in addition is a `given` instance of type
 `FromDigits.Floating[BigFloat]`:
+
 ```scala
    given FromDigits: FromDigits.Floating[BigFloat] with
       def fromDigits(digits: String) = apply(digits)
 end BigFloat
 ```
+
 Note that the `apply` method does not check the format of the `digits` argument. It is
 assumed that only valid arguments are passed. For calls coming from the compiler
 that assumption is valid, since the compiler will first check whether a numeric
@@ -164,35 +182,42 @@ literal has the correct format before it gets passed on to a conversion method.
 ### Compile-Time Errors
 
 With the setup of the previous section, a literal like
+
 ```scala
 1e10_0000_000_000: BigFloat
 ```
+
 would be expanded by the compiler to
+
 ```scala
 BigFloat.FromDigits.fromDigits("1e100000000000")
 ```
+
 Evaluating this expression throws a `NumberTooLarge` exception at run time. We would like it to
 produce a compile-time error instead. We can achieve this by tweaking the `BigFloat` class
 with a small dose of metaprogramming. The idea is to turn the `fromDigits` method
 into a macro, i.e. make it an inline method with a splice as right hand side.
 To do this, replace the `FromDigits` instance in the `BigFloat` object by the following two definitions:
+
 ```scala
 object BigFloat:
    ...
 
    class FromDigits extends FromDigits.Floating[BigFloat]:
       def fromDigits(digits: String) = apply(digits)
 
-   given FromDigits:
+   given FromDigits with
       override inline def fromDigits(digits: String) = ${
         fromDigitsImpl('digits)
       }
 ```
+
 Note that an inline method cannot directly fill in for an abstract method, since it produces
 no code that can be executed at runtime. That is why we define an intermediary class
 `FromDigits` that contains a fallback implementation which is then overridden by the inline
 method in the `FromDigits` given instance. That method is defined in terms of a macro
 implementation method `fromDigitsImpl`. Here is its definition:
+
 ```scala
    private def fromDigitsImpl(digits: Expr[String])(using ctx: Quotes): Expr[BigFloat] =
       digits.value match
@@ -207,6 +232,7 @@ implementation method `fromDigitsImpl`. Here is its definition:
             '{apply($digits)}
 end BigFloat
 ```
+
 The macro implementation takes an argument of type `Expr[String]` and yields
 a result of type `Expr[BigFloat]`. It tests whether its argument is a constant
 string. If that is the case, it converts the string using the `apply` method
@@ -218,10 +244,13 @@ The interesting part is the `catch` part of the case where `digits` is constant.
 If the `apply` method throws a `FromDigitsException`, the exception's message is issued as a compile time error in the `ctx.error(ex.getMessage)` call.
 
 With this new implementation, a definition like
+
 ```scala
 val x: BigFloat = 1234.45e3333333333
 ```
+
 would give a compile time error message:
+
 ```scala
 3 |  val x: BigFloat = 1234.45e3333333333
   |                    ^^^^^^^^^^^^^^^^^^