Ben Gamari pushed to branch wip/T25886 at Glasgow Haskell Compiler / GHC

Commits:

1 changed file:

Changes:

  • libraries/base/changelog.md
    ... ... @@ -308,29 +308,29 @@
    308 308
     
    
    309 309
       * Re-export the `IsList` typeclass from the new `GHC.IsList` module.
    
    310 310
     
    
    311
    -  * There's a new special function ``withDict`` in ``GHC.Exts``: ::
    
    311
    +  * There's a new special function `withDict` in `GHC.Exts`: ::
    
    312 312
     
    
    313 313
             withDict :: forall {rr :: RuntimeRep} cls meth (r :: TYPE rr). WithDict cls meth => meth -> (cls => r) -> r
    
    314 314
     
    
    315
    -    where ``cls`` must be a class containing exactly one method, whose type
    
    316
    -    must be ``meth``.
    
    315
    +    where `cls` must be a class containing exactly one method, whose type
    
    316
    +    must be `meth`.
    
    317 317
     
    
    318
    -    This function converts ``meth`` to a type class dictionary.
    
    319
    -    It removes the need for ``unsafeCoerce`` in implementation of reflection
    
    318
    +    This function converts `meth` to a type class dictionary.
    
    319
    +    It removes the need for `unsafeCoerce` in implementation of reflection
    
    320 320
         libraries. It should be used with care, because it can introduce
    
    321 321
         incoherent instances.
    
    322 322
     
    
    323
    -    For example, the ``withTypeable`` function from the
    
    324
    -    ``Type.Reflection`` module can now be defined as: ::
    
    323
    +    For example, the `withTypeable` function from the
    
    324
    +    `Type.Reflection` module can now be defined as: ::
    
    325 325
     
    
    326 326
               withTypeable :: forall k (a :: k) rep (r :: TYPE rep). ()
    
    327 327
                            => TypeRep a -> (Typeable a => r) -> r
    
    328 328
               withTypeable rep k = withDict @(Typeable a) rep k
    
    329 329
     
    
    330 330
         Note that the explicit type application is required, as the call to
    
    331
    -    ``withDict`` would be ambiguous otherwise.
    
    331
    +    `withDict` would be ambiguous otherwise.
    
    332 332
     
    
    333
    -    This replaces the old ``GHC.Exts.magicDict``, which required
    
    333
    +    This replaces the old `GHC.Exts.magicDict`, which required
    
    334 334
         an intermediate data type and was less reliable.
    
    335 335
     
    
    336 336
       * `Data.Word.Word64` and `Data.Int.Int64` are now always represented by
    
    ... ... @@ -348,17 +348,17 @@
    348 348
     
    
    349 349
       * Shipped with GHC 9.2.4
    
    350 350
     
    
    351
    -  * winio: make consoleReadNonBlocking not wait for any events at all.
    
    351
    +  * winio: make `consoleReadNonBlocking` not wait for any events at all.
    
    352 352
     
    
    353
    -  * winio: Add support to console handles to handleToHANDLE
    
    353
    +  * winio: Add support to console handles to `handleToHANDLE`
    
    354 354
     
    
    355 355
     ## 4.16.2.0 *May 2022*
    
    356 356
     
    
    357 357
       * Shipped with GHC 9.2.2
    
    358 358
     
    
    359
    -  * Export GHC.Event.Internal on Windows (#21245)
    
    359
    +  * Export `GHC.Event.Internal` on Windows (#21245)
    
    360 360
     
    
    361
    -  # Documentation Fixes
    
    361
    +  * Documentation Fixes
    
    362 362
     
    
    363 363
     ## 4.16.1.0 *Feb 2022*
    
    364 364
     
    
    ... ... @@ -427,10 +427,17 @@
    427 427
     
    
    428 428
         - Newtypes `And`, `Ior`, `Xor` and `Iff` which wrap their argument,
    
    429 429
           and whose `Semigroup` instances are defined using `(.&.)`, `(.|.)`, `xor`
    
    430
    -      and ```\x y -> complement (x `xor` y)```, respectively.
    
    430
    +      and `\x y -> complement (x `xor` y)`, respectively.
    
    431 431
     
    
    432 432
         - `oneBits :: FiniteBits a => a`, `oneBits = complement zeroBits`.
    
    433 433
     
    
    434
    +  * Various folding operations in `GHC.List` are now implemented via strict
    
    435
    +    folds:
    
    436
    +    - `sum`
    
    437
    +    - `product`
    
    438
    +    - `maximum`
    
    439
    +    - `minimum`
    
    440
    +
    
    434 441
     ## 4.15.0.0 *Feb 2021*
    
    435 442
     
    
    436 443
       * Shipped with GHC 9.0.1