Documentation: use https linkswip/doc-fixes

36 files changed, 86 insertions, 85 deletions

diff --git a/.gitlab/linters/check-cpp.py b/.gitlab/linters/check-cpp.py
index 4483c0504f..f904d81f8b 100755
--- a/.gitlab/linters/check-cpp.py
+++ b/.gitlab/linters/check-cpp.py
@@ -24,6 +24,7 @@ linters = [
 for l in linters:
     # Need do document rules!
     l.add_path_filter(lambda path: path != Path('docs', 'coding-style.html'))
+    l.add_path_filter(lambda path: path != Path('docs', 'users_guide', 'utils.rst'))
     # Don't lint vendored code
     l.add_path_filter(lambda path: not path.name == 'config.guess')
     # Don't lint font files
diff --git a/docs/users_guide/bugs.rst b/docs/users_guide/bugs.rst
index df34f186e4..707b6e300b 100644
--- a/docs/users_guide/bugs.rst
+++ b/docs/users_guide/bugs.rst
@@ -232,12 +232,12 @@ The Haskell Report specifies that a group of bindings (at top level, or
 in a ``let`` or ``where``) should be sorted into strongly-connected
 components, and then type-checked in dependency order
 (`Haskell Report, Section
-4.5.1 <http://www.haskell.org/onlinereport/decls.html#sect4.5.1>`__). As
+4.5.1 <https://www.haskell.org/onlinereport/decls.html#sect4.5.1>`__). As
 each group is type-checked, any binders of the group that have an
 explicit type signature are put in the type environment with the
 specified polymorphic type, and all others are monomorphic until the
 group is generalised (`Haskell Report, Section
-4.5.2 <http://www.haskell.org/onlinereport/decls.html#sect4.5.2>`__).
+4.5.2 <https://www.haskell.org/onlinereport/decls.html#sect4.5.2>`__).
 
 Following a suggestion of Mark Jones, in his paper `Typing Haskell in
 Haskell <https://web.cecs.pdx.edu/~mpj/thih/>`__, GHC implements a
@@ -327,7 +327,7 @@ GHC requires the use of ``hs-boot`` files to cut the recursive loops
 among mutually recursive modules as described in
 :ref:`mutual-recursion`. This more of an infelicity than a bug: the
 Haskell Report says (`Section
-5.7 <http://haskell.org/onlinereport/modules.html#sect5.7>`__)
+5.7 <https://haskell.org/onlinereport/modules.html#sect5.7>`__)
 
     "Depending on the Haskell implementation used, separate compilation of
     mutually recursive modules may require that imported modules contain
@@ -629,7 +629,7 @@ Bugs in GHC
    contrived one, that makes GHC diverge, and fixing the problem would
    impose an extra overhead on every compilation. So the bug remains
    un-fixed. There is more background in `Secrets of the GHC
-   inliner <http://research.microsoft.com/~simonpj/Papers/inlining/>`__.
+   inliner <https://research.microsoft.com/~simonpj/Papers/inlining/>`__.
 
 -  On 32-bit x86 platforms when using the native code generator, the
    :ghc-flag:`-fexcess-precision` option is always on.
diff --git a/docs/users_guide/codegens.rst b/docs/users_guide/codegens.rst
index 1cad4b7659..441d4900d6 100644
--- a/docs/users_guide/codegens.rst
+++ b/docs/users_guide/codegens.rst
@@ -34,7 +34,7 @@ LLVM Code Generator (``-fllvm``)
 .. index::
    single: LLVM code generator
 
-This is an alternative backend that uses the `LLVM <http://llvm.org>`__
+This is an alternative backend that uses the `LLVM <https://llvm.org>`__
 compiler to produce executable code. It generally produces code with
 performance as good as the native code generator but for some cases can
 produce much faster code. This is especially true for numeric, array
@@ -46,7 +46,7 @@ You must install and have LLVM available on your ``PATH`` for the LLVM code
 generator to work. Specifically GHC needs to be able to call the ``opt``
 and ``llc`` tools. Secondly, if you are running Mac OS X with LLVM 3.0
 or greater then you also need the `Clang C
-compiler <http://clang.llvm.org>`__ compiler available on your ``PATH``.
+compiler <https://clang.llvm.org>`__ compiler available on your ``PATH``.
 
 .. note::
 
@@ -60,12 +60,12 @@ To install LLVM and Clang:
 -  *Mac OS X*: Clang is included by default on recent OS X machines when
    Xcode is installed (from 10.6 and later). LLVM is not included.
    In order to use the LLVM based code generator, you should install the
-   `Homebrew <http://mxcl.github.com/homebrew/>`__ package manager for
+   `Homebrew <https://github.com/Homebrew/brew>`__ package manager for
    OS X. Alternatively you can download binaries for LLVM and Clang from
-   `here <http://llvm.org/releases/download.html>`__.
+   `here <https://llvm.org/releases/download.html>`__.
 
 -  *Windows*: You should download binaries for LLVM and clang from
-   `here <http://llvm.org/releases/download.html>`__.
+   `here <https://llvm.org/releases/download.html>`__.
 
 .. _c-code-gen:
 
diff --git a/docs/users_guide/debug-info.rst b/docs/users_guide/debug-info.rst
index 932cbf2b2e..ff0c9430e4 100644
--- a/docs/users_guide/debug-info.rst
+++ b/docs/users_guide/debug-info.rst
@@ -334,7 +334,7 @@ Further Reading
 
 For more information about the debug information produced by GHC see
 Peter Wortmann's PhD thesis, `*Profiling Optimized Haskell: Causal
-Analysis and Implementation* <http://etheses.whiterose.ac.uk/8321/>`__.
+Analysis and Implementation* <https://etheses.whiterose.ac.uk/8321/>`__.
 
 
 Direct Mapping
diff --git a/docs/users_guide/extending_ghc.rst b/docs/users_guide/extending_ghc.rst
index 7b3f7f0a78..309fa6c912 100644
--- a/docs/users_guide/extending_ghc.rst
+++ b/docs/users_guide/extending_ghc.rst
@@ -163,7 +163,7 @@ Compiling it results in:
 
 For more information on using the API, as well as more samples and
 references, please see `this Haskell.org wiki
-page <http://haskell.org/haskellwiki/GHC/As_a_library>`__.
+page <https://haskell.org/haskellwiki/GHC/As_a_library>`__.
 
 .. _compiler-plugins:
 
@@ -172,7 +172,7 @@ Compiler Plugins
 
 GHC has the ability to load compiler plugins at compile time. The
 feature is similar to the one provided by
-`GCC <http://gcc.gnu.org/wiki/plugins>`__, and allows users to write
+`GCC <https://gcc.gnu.org/wiki/plugins>`__, and allows users to write
 plugins that can adjust the behaviour of the constraint solver, inspect
 and modify the compilation pipeline, as well as transform and inspect
 GHC's intermediate language, Core. Plugins are suitable for experimental
diff --git a/docs/users_guide/exts/arrows.rst b/docs/users_guide/exts/arrows.rst
index f1e80f6ff7..e0be97853a 100644
--- a/docs/users_guide/exts/arrows.rst
+++ b/docs/users_guide/exts/arrows.rst
@@ -18,29 +18,29 @@ more details, see
    a friendly introduction, motivated with programming examples.
 
 -  “\ `A New Notation for
-   Arrows <http://www.soi.city.ac.uk/~ross/papers/notation.html>`__\ ”,
+   Arrows <https://www.soi.city.ac.uk/~ross/papers/notation.html>`__\ ”,
    Ross Paterson, in ICFP, Sep 2001. Introduced the notation described
    here.
 
 -  “\ `Arrows and
-   Computation <http://www.soi.city.ac.uk/~ross/papers/fop.html>`__\ ”,
+   Computation <https://www.soi.city.ac.uk/~ross/papers/fop.html>`__\ ”,
    Ross Paterson, in The Fun of Programming, Palgrave, 2003.
 
 -  “\ `Programming with
-   Arrows <http://www.cse.chalmers.se/~rjmh/afp-arrows.pdf>`__\ ”, John
+   Arrows <https://www.cse.chalmers.se/~rjmh/afp-arrows.pdf>`__\ ”, John
    Hughes, in 5th International Summer School on Advanced Functional
    Programming, Lecture Notes in Computer Science vol. 3622, Springer,
    2004. This paper includes another introduction to the notation, with
    practical examples.
 
 -  “\ `Type and Translation Rules for Arrow Notation in
-   GHC <http://www.haskell.org/ghc/docs/papers/arrow-rules.pdf>`__\ ”,
+   GHC <https://www.haskell.org/ghc/docs/papers/arrow-rules.pdf>`__\ ”,
    Ross Paterson and Simon Peyton Jones, September 16, 2004. A terse
    enumeration of the formal rules used (extracted from comments in the
    source code).
 
 -  The arrows web page at
-   ``http://www.haskell.org/arrows/`` <http://www.haskell.org/arrows/>`__.
+   ``https://www.haskell.org/arrows/`` <https://www.haskell.org/arrows/>`__.
 
 With the :extension:`Arrows` extension, GHC supports the arrow notation described in
 the second of these papers, translating it using combinators from the
@@ -395,7 +395,7 @@ Portability
 
 Although only GHC implements arrow notation directly, there is also a
 preprocessor (available from the `arrows web
-page <http://www.haskell.org/arrows/>`__) that translates arrow notation
+page <https://www.haskell.org/arrows/>`__) that translates arrow notation
 into Haskell 98 for use with other Haskell systems. You would still want
 to check arrow programs with GHC; tracing type errors in the
 preprocessor output is not easy. Modules intended for both GHC and the
diff --git a/docs/users_guide/exts/concurrent.rst b/docs/users_guide/exts/concurrent.rst
index 027c2b9adb..482882f3a2 100644
--- a/docs/users_guide/exts/concurrent.rst
+++ b/docs/users_guide/exts/concurrent.rst
@@ -11,7 +11,7 @@ is enabled by default, so no special flags are required. The `Concurrent
 Haskell
 paper <https://www.haskell.org/ghc/docs/papers/concurrent-haskell.ps.gz>`__
 is still an excellent resource, as is `Tackling the awkward
-squad <http://research.microsoft.com/%7Esimonpj/papers/marktoberdorf/>`__.
+squad <https://research.microsoft.com/%7Esimonpj/papers/marktoberdorf/>`__.
 
 To the programmer, Concurrent Haskell introduces no new language
 constructs; rather, it appears simply as a library,
@@ -51,7 +51,7 @@ way to do so is forking threads using Concurrent Haskell
 parallelism from pure code is to use the ``par`` combinator, which is
 closely related to (and often used with) ``seq``. Both of these are
 available from the
-`parallel library <http://hackage.haskell.org/package/parallel>`__:
+`parallel library <https://hackage.haskell.org/package/parallel>`__:
 
 ::
 
@@ -110,6 +110,6 @@ working from the runtime statistics; see :ref:`rts-options-gc`.
 
 More sophisticated combinators for expressing parallelism are available
 from the ``Control.Parallel.Strategies`` module in the `parallel
-package <http://hackage.haskell.org/package/parallel>`__. This module
+package <https://hackage.haskell.org/package/parallel>`__. This module
 builds functionality around ``par``, expressing more elaborate patterns
 of parallel computation, such as parallel ``map``.
diff --git a/docs/users_guide/exts/data_kinds.rst b/docs/users_guide/exts/data_kinds.rst
index 86bd8832f5..75e60f6a0f 100644
--- a/docs/users_guide/exts/data_kinds.rst
+++ b/docs/users_guide/exts/data_kinds.rst
@@ -13,7 +13,7 @@ Datatype promotion
 This section describes *data type promotion*, an extension to the kind
 system that complements kind polymorphism. It is enabled by
 :extension:`DataKinds`, and described in more detail in the paper `Giving
-Haskell a Promotion <http://dreixel.net/research/pdf/ghp.pdf>`__, which
+Haskell a Promotion <https://dreixel.net/research/pdf/ghp.pdf>`__, which
 appeared at TLDI 2012.
 
 Motivation
diff --git a/docs/users_guide/exts/defer_type_errors.rst b/docs/users_guide/exts/defer_type_errors.rst
index 6f2a871709..c9e4accb13 100644
--- a/docs/users_guide/exts/defer_type_errors.rst
+++ b/docs/users_guide/exts/defer_type_errors.rst
@@ -20,7 +20,7 @@ ignore the problems in ``a``.
 
 For more motivation and details please refer to the
 :ghc-wiki:`Wiki <defer-errors-to-runtime>` page or the `original
-paper <http://dreixel.net/research/pdf/epdtecp.pdf>`__.
+paper <https://dreixel.net/research/pdf/epdtecp.pdf>`__.
 
 Enabling deferring of type errors
 ---------------------------------
diff --git a/docs/users_guide/exts/gadt.rst b/docs/users_guide/exts/gadt.rst
index 99c3782650..00820739c9 100644
--- a/docs/users_guide/exts/gadt.rst
+++ b/docs/users_guide/exts/gadt.rst
@@ -44,7 +44,7 @@ the type ``a`` is refined to ``Int``. That's the whole point! A precise
 specification of the type rules is beyond what this user manual aspires
 to, but the design closely follows that described in the paper `Simple
 unification-based type inference for
-GADTs <http://research.microsoft.com/%7Esimonpj/papers/gadt/>`__, (ICFP
+GADTs <https://research.microsoft.com/%7Esimonpj/papers/gadt/>`__, (ICFP
 2006). The general principle is this: *type refinement is only carried
 out based on user-supplied type annotations*. So if no type signature is
 supplied for ``eval``, no type refinement happens, and lots of obscure
@@ -61,9 +61,9 @@ expression. Hence the addition ``i+j`` is legal.
 
 These and many other examples are given in papers by Hongwei Xi, and Tim
 Sheard. There is a longer introduction `on the
-wiki <http://www.haskell.org/haskellwiki/GADT>`__, and Ralf Hinze's `Fun
+wiki <https://www.haskell.org/haskellwiki/GADT>`__, and Ralf Hinze's `Fun
 with phantom
-types <http://www.cs.ox.ac.uk/ralf.hinze/publications/With.pdf>`__ also
+types <https://www.cs.ox.ac.uk/ralf.hinze/publications/With.pdf>`__ also
 has a number of examples. Note that papers may use different notation to
 that implemented in GHC.
 
@@ -135,7 +135,7 @@ also sets :extension:`GADTSyntax` and :extension:`MonoLocalBinds`.
    binding site. The easiest way to ensure that a variable a rigid type
    is to give it a type signature. For more precise details see `Simple
    unification-based type inference for
-   GADTs <http://research.microsoft.com/%7Esimonpj/papers/gadt/>`__. The
+   GADTs <https://research.microsoft.com/%7Esimonpj/papers/gadt/>`__. The
    criteria implemented by GHC are given in the Appendix.
 
 -  When GHC typechecks multiple patterns in a function clause, it typechecks
diff --git a/docs/users_guide/exts/generics.rst b/docs/users_guide/exts/generics.rst
index d32fa246bb..05015637aa 100644
--- a/docs/users_guide/exts/generics.rst
+++ b/docs/users_guide/exts/generics.rst
@@ -255,18 +255,18 @@ generic implementation of serialization. If you are using
 :extension:`DeriveAnyClass`, the same instance is generated by simply attaching
 a ``deriving Serialize`` clause to the ``UserTree`` datatype
 declaration. For more examples of generic functions please refer to the
-`generic-deriving <http://hackage.haskell.org/package/generic-deriving>`__
+`generic-deriving <https://hackage.haskell.org/package/generic-deriving>`__
 package on Hackage.
 
 More information
 ----------------
 
 For more details please refer to the `Haskell Wiki
-page <http://www.haskell.org/haskellwiki/GHC.Generics>`__ or the
+page <https://www.haskell.org/haskellwiki/GHC.Generics>`__ or the
 original paper [Generics2010]_.
 
 .. [Generics2010] Jose Pedro Magalhaes, Atze Dijkstra, Johan Jeuring, and Andres Loeh.
    `A generic deriving mechanism for Haskell
-   <http://dreixel.net/research/pdf/gdmh.pdf>`__. Proceedings of
+   <https://dreixel.net/research/pdf/gdmh.pdf>`__. Proceedings of
    the third ACM Haskell symposium on Haskell (Haskell'2010), pp. 37-48,
    ACM, 2010.
diff --git a/docs/users_guide/exts/hiding_unexported.rst b/docs/users_guide/exts/hiding_unexported.rst
index 8e295ca7eb..811a866513 100644
--- a/docs/users_guide/exts/hiding_unexported.rst
+++ b/docs/users_guide/exts/hiding_unexported.rst
@@ -12,7 +12,7 @@ Technically in Haskell 2010 this is illegal: ::
 
 The ``import A hiding( g )`` in module ``B`` is technically an error
 (`Haskell Report,
-5.3.1 <http://www.haskell.org/onlinereport/haskell2010/haskellch5.html#x11-1020005.3.1>`__)
+5.3.1 <https://www.haskell.org/onlinereport/haskell2010/haskellch5.html#x11-1020005.3.1>`__)
 because ``A`` does not export ``g``. However GHC allows it, in the
 interests of supporting backward compatibility; for example, a newer
 version of ``A`` might export ``g``, and you want ``B`` to work in
diff --git a/docs/users_guide/exts/monomorphism.rst b/docs/users_guide/exts/monomorphism.rst
index d71984b26f..7ca01cc9b0 100644
--- a/docs/users_guide/exts/monomorphism.rst
+++ b/docs/users_guide/exts/monomorphism.rst
@@ -13,7 +13,7 @@ Switching off the Monomorphism Restriction
     bindings lacking explicit type signatures.
 
 Haskell's monomorphism restriction (see `Section
-4.5.5 <http://www.haskell.org/onlinereport/decls.html#sect4.5.5>`__ of
+4.5.5 <https://www.haskell.org/onlinereport/decls.html#sect4.5.5>`__ of
 the Haskell Report) can be completely switched off by
 :extension:`NoMonomorphismRestriction`. Since GHC 7.8.1, the monomorphism
 restriction is switched off by default in GHCi's interactive options
diff --git a/docs/users_guide/exts/overloaded_strings.rst b/docs/users_guide/exts/overloaded_strings.rst
index 9c12e81c29..848bc5a271 100644
--- a/docs/users_guide/exts/overloaded_strings.rst
+++ b/docs/users_guide/exts/overloaded_strings.rst
@@ -39,7 +39,7 @@ mention it explicitly (for example, to give an instance declaration for
 it), you can import it from module ``Data.String``.
 
 Haskell's defaulting mechanism (`Haskell Report, Section
-4.3.4 <http://www.haskell.org/onlinereport/decls.html#sect4.3.4>`__) is
+4.3.4 <https://www.haskell.org/onlinereport/decls.html#sect4.3.4>`__) is
 extended to cover string literals, when :extension:`OverloadedStrings` is
 specified. Specifically:
 
diff --git a/docs/users_guide/exts/pattern_guards.rst b/docs/users_guide/exts/pattern_guards.rst
index 009dabaa30..cfa6b7783d 100644
--- a/docs/users_guide/exts/pattern_guards.rst
+++ b/docs/users_guide/exts/pattern_guards.rst
@@ -11,6 +11,6 @@ Pattern guards
     :since: 6.8.1
 
 Disable `pattern guards
-<http://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-460003.13>`__.
+<https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-460003.13>`__.
 
 
diff --git a/docs/users_guide/exts/poly_kinds.rst b/docs/users_guide/exts/poly_kinds.rst
index edd1856759..25843aedb0 100644
--- a/docs/users_guide/exts/poly_kinds.rst
+++ b/docs/users_guide/exts/poly_kinds.rst
@@ -77,7 +77,7 @@ run to completion, their results indeed have the types assigned. It makes no
 claim about programs that do not finish in a finite amount of time.
 
 To learn more about this decision and the design of GHC under the hood
-please see the `paper <http://www.seas.upenn.edu/~sweirich/papers/fckinds.pdf>`__
+please see the `paper <https://www.seas.upenn.edu/~sweirich/papers/fckinds.pdf>`__
 introducing this kind system to GHC/Haskell.
 
 Principles of kind inference
diff --git a/docs/users_guide/exts/pragmas.rst b/docs/users_guide/exts/pragmas.rst
index fd0127f54a..3424c3f30d 100644
--- a/docs/users_guide/exts/pragmas.rst
+++ b/docs/users_guide/exts/pragmas.rst
@@ -303,7 +303,7 @@ has a number of other effects:
 GHC ensures that inlining cannot go on forever: every mutually-recursive
 group is cut by one or more *loop breakers* that is never inlined (see
 `Secrets of the GHC inliner, JFP 12(4) July
-2002 <http://research.microsoft.com/%7Esimonpj/Papers/inlining/index.htm>`__).
+2002 <https://research.microsoft.com/%7Esimonpj/Papers/inlining/index.htm>`__).
 GHC tries not to select a function with an ``INLINE`` pragma as a loop
 breaker, but when there is no choice even an INLINE function can be
 selected, in which case the ``INLINE`` pragma is ignored. For example, for a
diff --git a/docs/users_guide/exts/quantified_constraints.rst b/docs/users_guide/exts/quantified_constraints.rst
index 2ed53b6c4a..3b5b92a7b6 100644
--- a/docs/users_guide/exts/quantified_constraints.rst
+++ b/docs/users_guide/exts/quantified_constraints.rst
@@ -134,13 +134,13 @@ Notes:
 
   See `Iceland Jack's summary <https://gitlab.haskell.org/ghc/ghc/issues/14733#note_148352>`_.  The key point is that the bit to the right of the ``=>`` may be headed by a type *variable* (``c`` in this case), rather than a class.  It should not be one of the forall'd variables, though.
 
-  (NB: this goes beyond what is described in `the paper <http://i.cs.hku.hk/~bruno//papers/hs2017.pdf>`_, but does not seem to introduce any new technical difficulties.)
+  (NB: this goes beyond what is described in `the paper <https://i.cs.hku.hk/~bruno//papers/hs2017.pdf>`_, but does not seem to introduce any new technical difficulties.)
 
 
 Typing changes
 ----------------
 
-See `the paper <http://i.cs.hku.hk/~bruno//papers/hs2017.pdf>`_.
+See `the paper <https://i.cs.hku.hk/~bruno//papers/hs2017.pdf>`_.
 
 Superclasses
 ----------------
@@ -152,7 +152,7 @@ Suppose we have::
 
 From the ``x==x`` we need an ``Eq (m Int)`` constraint, but the context only gives us a way to figure out ``Ord (m a)`` constraints.  But from the given constraint ``forall a. Ord a => Ord (m a)`` we derive a second given constraint ``forall a. Ord a => Eq (m a)``, and from that we can readily solve ``Eq (m Int)``.  This process is very similar to the way that superclasses already work: given an ``Ord a`` constraint we derive a second given ``Eq a`` constraint.
 
-NB: This treatment of superclasses goes beyond `the paper <http://i.cs.hku.hk/~bruno//papers/hs2017.pdf>`_, but is specifically desired by users.
+NB: This treatment of superclasses goes beyond `the paper <https://i.cs.hku.hk/~bruno//papers/hs2017.pdf>`_, but is specifically desired by users.
 
 Overlap
 -------------
diff --git a/docs/users_guide/exts/recursive_do.rst b/docs/users_guide/exts/recursive_do.rst
index 2f6d3e36db..a67a4bb409 100644
--- a/docs/users_guide/exts/recursive_do.rst
+++ b/docs/users_guide/exts/recursive_do.rst
@@ -58,9 +58,9 @@ As you can guess ``justOnes`` will evaluate to ``Just [-1,-1,-1,...``.
 
 GHC's implementation the mdo-notation closely follows the original
 translation as described in the paper `A recursive do for
-Haskell <http://leventerkok.github.io/papers/recdo.pdf>`__, which
+Haskell <https://leventerkok.github.io/papers/recdo.pdf>`__, which
 in turn is based on the work `Value Recursion in Monadic
-Computations <http://leventerkok.github.io/papers/erkok-thesis.pdf>`__.
+Computations <https://leventerkok.github.io/papers/erkok-thesis.pdf>`__.
 Furthermore, GHC extends the syntax described in the former paper with a
 lower level syntax flagged by the ``rec`` keyword, as we describe next.
 
@@ -121,7 +121,7 @@ can be rather delicate: in particular, we would like the knots to be
 wrapped around as minimal groups as possible. This process is known as
 *segmentation*, and is described in detail in Section 3.2 of `A
 recursive do for
-Haskell <http://leventerkok.github.io/papers/recdo.pdf>`__.
+Haskell <https://leventerkok.github.io/papers/recdo.pdf>`__.
 Segmentation improves polymorphism and reduces the size of the recursive
 knot. Most importantly, it avoids unnecessary interference caused by a
 fundamental issue with the so-called *right-shrinking* axiom for monadic
@@ -130,7 +130,7 @@ recursion. In brief, most monads of interest (IO, strict state, etc.) do
 performing segmentation can cause unnecessary interference, changing the
 termination behavior of the resulting translation. (Details can be found
 in Sections 3.1 and 7.2.2 of `Value Recursion in Monadic
-Computations <http://leventerkok.github.io/papers/erkok-thesis.pdf>`__.)
+Computations <https://leventerkok.github.io/papers/erkok-thesis.pdf>`__.)
 
 The ``mdo`` notation removes the burden of placing explicit ``rec``
 blocks in the code. Unlike an ordinary ``do`` expression, in which
diff --git a/docs/users_guide/exts/roles.rst b/docs/users_guide/exts/roles.rst
index a92a78787d..1e3e8ddaeb 100644
--- a/docs/users_guide/exts/roles.rst
+++ b/docs/users_guide/exts/roles.rst
@@ -40,7 +40,7 @@ variables of datatypes, classes, and type synonyms.
 
 Roles as implemented in GHC are a from a simplified version of the work
 described in `Generative type abstraction and type-level
-computation <http://www.seas.upenn.edu/~sweirich/papers/popl163af-weirich.pdf>`__,
+computation <https://www.seas.upenn.edu/~sweirich/papers/popl163af-weirich.pdf>`__,
 published at POPL 2011.
 
 .. _nominal-representational-and-phantom:
diff --git a/docs/users_guide/exts/scoped_type_variables.rst b/docs/users_guide/exts/scoped_type_variables.rst
index d80eb40d0d..d8a3885fa3 100644
--- a/docs/users_guide/exts/scoped_type_variables.rst
+++ b/docs/users_guide/exts/scoped_type_variables.rst
@@ -87,7 +87,7 @@ A *lexically scoped type variable* can be bound by:
 
 In Haskell, a programmer-written type signature is implicitly quantified
 over its free type variables (`Section
-4.1.2 <http://www.haskell.org/onlinereport/decls.html#sect4.1.2>`__ of
+4.1.2 <https://www.haskell.org/onlinereport/decls.html#sect4.1.2>`__ of
 the Haskell Report). Lexically scoped type variables affect this
 implicit quantification rules as follows: any type variable that is in
 scope is *not* universally quantified. For example, if type variable
diff --git a/docs/users_guide/exts/static_pointers.rst b/docs/users_guide/exts/static_pointers.rst
index b780f07ecf..e142b14be2 100644
--- a/docs/users_guide/exts/static_pointers.rst
+++ b/docs/users_guide/exts/static_pointers.rst
@@ -24,7 +24,7 @@ With this extension turned on, ``static`` is no longer a valid
 identifier.
 
 Static pointers were first proposed in the paper `Towards Haskell in the
-cloud <http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/remote.pdf>`__,
+cloud <https://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/remote.pdf>`__,
 Jeff Epstein, Andrew P. Black and Simon Peyton-Jones, Proceedings of the
 4th ACM Symposium on Haskell, pp. 118-129, ACM, 2011.
 
diff --git a/docs/users_guide/exts/stm.rst b/docs/users_guide/exts/stm.rst
index efa7a010a2..b60c21999b 100644
--- a/docs/users_guide/exts/stm.rst
+++ b/docs/users_guide/exts/stm.rst
@@ -7,7 +7,7 @@ papers <https://wiki.haskell.org/Research_papers/Parallelism_and_concurrency#Loc
 are an excellent introduction to what STM is, and how to use it.
 
 The main library you need to use is the `stm
-library <http://hackage.haskell.org/package/stm>`__. The main features
+library <https://hackage.haskell.org/package/stm>`__. The main features
 supported are these:
 
 -  Atomic blocks.
diff --git a/docs/users_guide/exts/strict.rst b/docs/users_guide/exts/strict.rst
index 4e0cb61bdc..75051a9d5f 100644
--- a/docs/users_guide/exts/strict.rst
+++ b/docs/users_guide/exts/strict.rst
@@ -351,7 +351,7 @@ Dynamic semantics of bang patterns
 ----------------------------------
 
 The semantics of Haskell pattern matching is described in `Section
-3.17.2 <http://www.haskell.org/onlinereport/exps.html#sect3.17.2>`__ of
+3.17.2 <https://www.haskell.org/onlinereport/exps.html#sect3.17.2>`__ of
 the Haskell Report. To this description add one extra item 10, saying:
 
 -  Matching the pattern ``!pat`` against a value ``v`` behaves as
@@ -362,14 +362,14 @@ the Haskell Report. To this description add one extra item 10, saying:
    -  otherwise, ``pat`` is matched against ``v``
 
 Similarly, in Figure 4 of `Section
-3.17.3 <http://www.haskell.org/onlinereport/exps.html#sect3.17.3>`__,
+3.17.3 <https://www.haskell.org/onlinereport/exps.html#sect3.17.3>`__,
 add a new case (t): ::
 
     case v of { !pat -> e; _ -> e' }
        = v `seq` case v of { pat -> e; _ -> e' }
 
 That leaves let expressions, whose translation is given in `Section
-3.12 <http://www.haskell.org/onlinereport/exps.html#sect3.12>`__ of the
+3.12 <https://www.haskell.org/onlinereport/exps.html#sect3.12>`__ of the
 Haskell Report.
 Replace the "Translation" there with the following one.  Given
 ``let { bind1 ... bindn } in body``:
diff --git a/docs/users_guide/exts/template_haskell.rst b/docs/users_guide/exts/template_haskell.rst
index 8e617f3852..1ebbe5a174 100644
--- a/docs/users_guide/exts/template_haskell.rst
+++ b/docs/users_guide/exts/template_haskell.rst
@@ -6,10 +6,10 @@ Template Haskell
 Template Haskell allows you to do compile-time meta-programming in
 Haskell. The background to the main technical innovations is discussed
 in "`Template Meta-programming for
-Haskell <http://research.microsoft.com/~simonpj/papers/meta-haskell/>`__"
+Haskell <https://research.microsoft.com/~simonpj/papers/meta-haskell/>`__"
 (Proc Haskell Workshop 2002).
 
-The `Template Haskell <http://www.haskell.org/haskellwiki/Template_Haskell>`__
+The `Template Haskell <https://www.haskell.org/haskellwiki/Template_Haskell>`__
 page on the GHC Wiki has a wealth of information. You may also consult the
 Haddock reference documentation :th-ref:`Language.Haskell.TH.`.
 Many changes to the original
@@ -22,7 +22,7 @@ as a worked example to help get you started.
 
 The documentation here describes the realisation of Template Haskell in
 GHC. It is not detailed enough to understand Template Haskell; see the
-`Wiki page <http://haskell.org/haskellwiki/Template_Haskell>`__.
+`Wiki page <https://haskell.org/haskellwiki/Template_Haskell>`__.
 
 .. _th-syntax:
 
@@ -627,7 +627,7 @@ Quasi-quotation allows patterns and expressions to be written using
 programmer-defined concrete syntax; the motivation behind the extension
 and several examples are documented in "`Why It's Nice to be Quoted:
 Quasiquoting for
-Haskell <http://www.cs.tufts.edu/comp/150FP/archive/geoff-mainland/quasiquoting.pdf>`__"
+Haskell <https://www.cs.tufts.edu/comp/150FP/archive/geoff-mainland/quasiquoting.pdf>`__"
 (Proc Haskell Workshop 2007). The example below shows how to write a
 quasiquoter for a simple expression language.
 
diff --git a/docs/users_guide/exts/type_families.rst b/docs/users_guide/exts/type_families.rst
index 15cf21e027..e040896235 100644
--- a/docs/users_guide/exts/type_families.rst
+++ b/docs/users_guide/exts/type_families.rst
@@ -46,7 +46,7 @@ The instances of data families can be data types and newtypes.
 Type families are enabled by the language extension :extension:`TypeFamilies`. Additional
 information on the use of type families in GHC is available on `the
 Haskell wiki page on type
-families <http://www.haskell.org/haskellwiki/GHC/Indexed_types>`__.
+families <https://www.haskell.org/haskellwiki/GHC/Indexed_types>`__.
 
 .. [AssocDataTypes2005]
     “`Associated Types with Class
@@ -941,7 +941,7 @@ Import and export
 -----------------
 
 The rules for export lists (Haskell Report `Section
-5.2 <http://www.haskell.org/onlinereport/modules.html#sect5.2>`__) need
+5.2 <https://www.haskell.org/onlinereport/modules.html#sect5.2>`__) need
 adjustment for type families:
 
 -  The form ``T(..)``, where ``T`` is a data family, names the family
@@ -1158,7 +1158,7 @@ extension.  This extension implies ``-XTypeFamilies``.
 
 For full details on injective type families refer to Haskell Symposium
 2015 paper `Injective type families for
-Haskell <http://ics.p.lodz.pl/~stolarek/_media/pl:research:stolarek_peyton-jones_eisenberg_injectivity_extended.pdf>`__.
+Haskell <https://ics.p.lodz.pl/~stolarek/_media/pl:research:stolarek_peyton-jones_eisenberg_injectivity_extended.pdf>`__.
 
 .. _injective-ty-fams-syntax:
 
diff --git a/docs/users_guide/exts/typeclasses.rst b/docs/users_guide/exts/typeclasses.rst
index 41aa4d985e..b8cdc312b7 100644
--- a/docs/users_guide/exts/typeclasses.rst
+++ b/docs/users_guide/exts/typeclasses.rst
@@ -6,7 +6,7 @@ Class and instances declarations
 This section documents GHC's type-class extensions.
 There's lots of background in the paper `Type classes: exploring the
 design
-space <http://research.microsoft.com/~simonpj/Papers/type-class-design-space/>`__
+space <https://research.microsoft.com/~simonpj/Papers/type-class-design-space/>`__
 (Simon Peyton Jones, Mark Jones, Erik Meijer).
 
 .. toctree::
diff --git a/docs/users_guide/exts/view_patterns.rst b/docs/users_guide/exts/view_patterns.rst
index a6fe54fa9c..d77a24cf53 100644
--- a/docs/users_guide/exts/view_patterns.rst
+++ b/docs/users_guide/exts/view_patterns.rst
@@ -103,7 +103,7 @@ follows:
    then the whole view pattern matches a ⟨T1⟩.
 
 -  Matching: To the equations in Section 3.17.3 of the `Haskell 98
-   Report <http://www.haskell.org/onlinereport/>`__, add the following: ::
+   Report <https://www.haskell.org/onlinereport/>`__, add the following: ::
 
        case v of { (e -> p) -> e1 ; _ -> e2 }
         =
@@ -120,7 +120,7 @@ follows:
    only applied once. Pattern compilation in GHC follows the matrix
    algorithm described in Chapter 4 of `The Implementation of Functional
    Programming
-   Languages <http://research.microsoft.com/~simonpj/Papers/slpj-book-1987/>`__.
+   Languages <https://research.microsoft.com/~simonpj/Papers/slpj-book-1987/>`__.
    When the top rows of the first column of a matrix are all view
    patterns with the "same" expression, these patterns are transformed
    into a single nested case. This includes, for example, adjacent view
diff --git a/docs/users_guide/ghci.rst b/docs/users_guide/ghci.rst
index f9d0a60df6..bec44f969a 100644
--- a/docs/users_guide/ghci.rst
+++ b/docs/users_guide/ghci.rst
@@ -3273,7 +3273,7 @@ running GHCi session while debugging it
 With this macro defined in your ``.ghci`` file, you can use
 ``:source file`` to read GHCi commands from ``file``. You can find (and
 contribute!-) other suggestions for ``.ghci`` files on this Haskell wiki
-page: `GHC/GHCi <http://haskell.org/haskellwiki/GHC/GHCi>`__
+page: `GHC/GHCi <https://haskell.org/haskellwiki/GHC/GHCi>`__
 
 Additionally, any files specified with :ghc-flag:`-ghci-script` flags will be
 read after the standard files, allowing the use of custom .ghci files.
diff --git a/docs/users_guide/intro.rst b/docs/users_guide/intro.rst
index 6c82851610..d25f2c4aa2 100644
--- a/docs/users_guide/intro.rst
+++ b/docs/users_guide/intro.rst
@@ -5,7 +5,7 @@ Introduction
 
 This is a guide to using the Glasgow Haskell Compiler (GHC): an
 interactive and batch compilation system for the
-`Haskell 2010 <http://www.haskell.org/>`__ language.
+`Haskell 2010 <https://www.haskell.org/>`__ language.
 
 GHC has two main components: an interactive Haskell interpreter (also
 known as GHCi), described in :ref:`ghci`, and a batch compiler,
@@ -45,7 +45,7 @@ documentation.
 Obtaining GHC
 -------------
 
-Go to the `GHC home page <http://www.haskell.org/ghc/>`__ and follow the
+Go to the `GHC home page <https://www.haskell.org/ghc/>`__ and follow the
 "download" link to download GHC for your platform.
 
 Alternatively, if you want to build GHC yourself, head on over to the
@@ -64,7 +64,7 @@ Meta-information: Web sites, mailing lists, etc.
 
 On the World-Wide Web, there are several URLs of likely interest:
 
--  `GHC home page <http://www.haskell.org/ghc/>`__
+-  `GHC home page <https://www.haskell.org/ghc/>`__
 
 -  `GHC Developers Home <https://gitlab.haskell.org/ghc/ghc>`__ (developer
    documentation, wiki, and bug tracker)
@@ -75,12 +75,12 @@ as you feel is appropriate.
 ``glasgow-haskell-users``
     This list is for GHC users to chat among themselves. If you have a
     specific question about GHC, please check the
-    `FAQ <http://www.haskell.org/haskellwiki/GHC/FAQ>`__ first.
+    `FAQ <https://www.haskell.org/haskellwiki/GHC/FAQ>`__ first.
 
     Subscribers can post to the list by sending their message to 
     glasgow-haskell-users@haskell.org. Further information can be found
     on the
-    `Mailman page <http://www.haskell.org/mailman/listinfo/glasgow-haskell-users>`__.
+    `Mailman page <https://www.haskell.org/mailman/listinfo/glasgow-haskell-users>`__.
 
 ``ghc-devs``
     The GHC developers hang out here. If you are working with the GHC API
@@ -88,10 +88,10 @@ as you feel is appropriate.
 
     Subscribers can post to the list by sending their message to 
     ghc-devs@haskell.org. Further information can be found on the
-    `Mailman page <http://www.haskell.org/mailman/listinfo/ghc-devs>`__.
+    `Mailman page <https://www.haskell.org/mailman/listinfo/ghc-devs>`__.
 
 There are several other Haskell and GHC-related mailing lists served by
-``www.haskell.org``. Go to http://www.haskell.org/mailman/listinfo/
+``www.haskell.org``. Go to https://www.haskell.org/mailman/listinfo/
 for the full list.
 
 .. _bug-reporting:
@@ -136,7 +136,7 @@ numbering GHC versions:
 
     We may make snapshot releases of the current stable branch
     `available for
-    download <http://www.haskell.org/ghc/dist/latest/>`__, and the
+    download <https://www.haskell.org/ghc/dist/latest/>`__, and the
     latest sources are available from
     :ghc-wiki:`the git repositories <repositories>`.
 
diff --git a/docs/users_guide/packages.rst b/docs/users_guide/packages.rst
index ff6953ac8c..2d515ee8e4 100644
--- a/docs/users_guide/packages.rst
+++ b/docs/users_guide/packages.rst
@@ -10,7 +10,7 @@ A package is a library of Haskell modules known to the compiler. GHC
 comes with several packages: see the accompanying `library
 documentation <../libraries/index.html>`__. More packages to install can
 be obtained from
-`HackageDB <http://hackage.haskell.org/packages/hackage.html>`__.
+`HackageDB <https://hackage.haskell.org/>`__.
 
 Using a package couldn't be simpler: if you're using ``--make`` or GHCi,
 then most of the installed packages will be automatically available to
@@ -18,11 +18,11 @@ your program without any further options. The exceptions to this rule
 are covered below in :ref:`using-packages`.
 
 Building your own packages is also quite straightforward: we provide the
-`Cabal <http://www.haskell.org/cabal/>`__ infrastructure which automates
+`Cabal <https://www.haskell.org/cabal/>`__ infrastructure which automates
 the process of configuring, building, installing and distributing a
 package. All you need to do is write a simple configuration file, put a
 few files in the right places, and you have a package. See the `Cabal
-documentation <http://www.haskell.org/cabal/users-guide/>`__ for
+documentation <https://www.haskell.org/cabal/users-guide/>`__ for
 details, and also the Cabal libraries
 (:cabal-ref:`Distribution.Simple.`, for example).
 
@@ -713,7 +713,7 @@ about the nature of the failure:
 To fix the problem, you need to recompile the broken packages against
 the new dependencies. The easiest way to do this is to use
 ``cabal-install``, or download the packages from
-`HackageDB <http://hackage.haskell.org/packages/hackage.html>`__ and
+`HackageDB <https://hackage.haskell.org/>`__ and
 build and install them as normal.
 
 Be careful not to recompile any packages that GHC itself depends on, as
@@ -853,7 +853,7 @@ instead of just package name and version, pass the ``--ipid`` flag.
 
 ``ghc-pkg dot``
     Generate a graph of the package dependencies in a form suitable for
-    input for the `graphviz <http://www.graphviz.org/>`__ tools. For
+    input for the `graphviz <https://www.graphviz.org/>`__ tools. For
     example, to generate a PDF of the dependency graph:
 
     ::
@@ -990,7 +990,7 @@ Building a package from Haskell source
    single: packages; building
 
 We don't recommend building packages the hard way. Instead, use the
-`Cabal <http://www.haskell.org/cabal/users-guide/>`__ infrastructure if
+`Cabal <https://www.haskell.org/cabal/users-guide/>`__ infrastructure if
 possible. If your package is particularly complicated or requires a lot
 of configuration, then you might have to fall back to the low-level
 mechanisms, so a few hints for those brave souls follow.
@@ -1438,7 +1438,7 @@ The allowed fields, with their types, are:
        single: haddock-interfaces; package specification
 
     (string list) A list of filenames containing
-    `Haddock <http://www.haskell.org/haddock/>`__ interface files
+    `Haddock <https://www.haskell.org/haddock/>`__ interface files
     (``.haddock`` files) for this package.
 
 ``haddock-html``
diff --git a/docs/users_guide/profiling.rst b/docs/users_guide/profiling.rst
index 803457fce9..4faa437bd8 100644
--- a/docs/users_guide/profiling.rst
+++ b/docs/users_guide/profiling.rst
@@ -743,7 +743,7 @@ from GHC's ``nofib`` benchmark suite,
 .. image:: images/prof_scc.*
 
 You might also want to take a look at
-`hp2any <http://www.haskell.org/haskellwiki/Hp2any>`__, a more advanced
+`hp2any <https://www.haskell.org/haskellwiki/Hp2any>`__, a more advanced
 suite of tools (not distributed with GHC) for displaying heap profiles.
 
 .. _rts-options-heap-prof:
@@ -1315,7 +1315,7 @@ counts are also stored in shared memory, and continuously updating them
 on multiple cores is extremely slow.
 
 We also recommend using
-`ThreadScope <http://www.haskell.org/haskellwiki/ThreadScope>`__ for
+`ThreadScope <https://www.haskell.org/haskellwiki/ThreadScope>`__ for
 profiling parallel programs; it offers a GUI for visualising parallel
 execution, and is complementary to the time and space profiling features
 provided with GHC.
diff --git a/docs/users_guide/runtime_control.rst b/docs/users_guide/runtime_control.rst
index f22c941dac..a10a283e52 100644
--- a/docs/users_guide/runtime_control.rst
+++ b/docs/users_guide/runtime_control.rst
@@ -1204,7 +1204,7 @@ When the program is linked with the :ghc-flag:`-eventlog` option
 
 -  In binary format to a file for later analysis by a variety of tools.
    One such tool is
-   `ThreadScope <http://www.haskell.org/haskellwiki/ThreadScope>`__,
+   `ThreadScope <https://www.haskell.org/haskellwiki/ThreadScope>`__,
    which interprets the event log to produce a visual parallel execution
    profile of the program.
 
@@ -1266,10 +1266,10 @@ When the program is linked with the :ghc-flag:`-eventlog` option
 
     The format of the log file is described in this users guide in
     :ref:`eventlog-encodings` It can be parsed in Haskell using the
-    `ghc-events <http://hackage.haskell.org/package/ghc-events>`__
+    `ghc-events <https://hackage.haskell.org/package/ghc-events>`__
     library. To dump the contents of a ``.eventlog`` file as text, use
     the tool ``ghc-events show`` that comes with the
-    `ghc-events <http://hackage.haskell.org/package/ghc-events>`__
+    `ghc-events <https://hackage.haskell.org/package/ghc-events>`__
     package.
 
     Each event is associated with a timestamp which is the number of
diff --git a/docs/users_guide/separate_compilation.rst b/docs/users_guide/separate_compilation.rst
index 9d11830237..2e4a0df1e2 100644
--- a/docs/users_guide/separate_compilation.rst
+++ b/docs/users_guide/separate_compilation.rst
@@ -855,7 +855,7 @@ GHC 8.2 supports module signatures (``hsig`` files), which allow you to
 write a signature in place of a module implementation, deferring the
 choice of implementation until a later point in time.  This feature is
 not intended to be used without `Cabal
-<http://www.haskell.org/cabal/>`__; this manual entry will focus
+<https://www.haskell.org/cabal/>`__; this manual entry will focus
 on the syntax and semantics of signatures.
 
 To start with an example, suppose you had a module ``A`` which made use of some
diff --git a/docs/users_guide/using-optimisation.rst b/docs/users_guide/using-optimisation.rst
index 31d3a71431..a57225da25 100644
--- a/docs/users_guide/using-optimisation.rst
+++ b/docs/users_guide/using-optimisation.rst
@@ -448,7 +448,7 @@ by saying ``-fno-wombat``.
 
     Float let-bindings inwards, nearer their binding
     site. See `Let-floating: moving bindings to give faster programs
-    (ICFP'96) <http://research.microsoft.com/en-us/um/people/simonpj/papers/float.ps.gz>`__.
+    (ICFP'96) <https://research.microsoft.com/en-us/um/people/simonpj/papers/float.ps.gz>`__.
 
     This optimisation moves let bindings closer to their use site. The
     benefit here is that this may avoid unnecessary allocation if the
@@ -476,7 +476,7 @@ by saying ``-fno-wombat``.
     let-floating), which floats let-bindings outside enclosing lambdas,
     in the hope they will be thereby be computed less often. See
     `Let-floating: moving bindings to give faster programs
-    (ICFP'96) <http://research.microsoft.com/en-us/um/people/simonpj/papers/float.ps.gz>`__.
+    (ICFP'96) <https://research.microsoft.com/en-us/um/people/simonpj/papers/float.ps.gz>`__.
     Full laziness increases sharing, which can lead to increased memory
     residency.
 
diff --git a/docs/users_guide/utils.rst b/docs/users_guide/utils.rst
index f490bfa2d8..3812a9d97e 100644
--- a/docs/users_guide/utils.rst
+++ b/docs/users_guide/utils.rst
@@ -24,7 +24,7 @@ Andy Gill and Simon Marlow have written a parser-generator for Haskell,
 called ``happy``. ``Happy`` is to Haskell what ``Yacc`` is to C.
 
 You can get ``happy`` from `the Happy
-Homepage <http://www.haskell.org/happy/>`__.
+Homepage <https://www.haskell.org/happy/>`__.
 
 ``Happy`` is at its shining best when compiled by GHC.