Documentation: use https links

23 files changed, 48 insertions, 48 deletions

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