summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorKrzysztof Gogolewski <krzysztof.gogolewski@tweag.io>2021-08-29 23:24:58 +0200
committerMarge Bot <ben+marge-bot@smart-cactus.org>2021-09-08 03:00:57 -0400
commit330e6e9c7a88d2be6d3f78eff44a9a6fcf9733a2 (patch)
tree149dc88608b6b771e79673d3f115d075f8763baf
parentdcc1599f74d8115b3bd1bd87648866d89070a7e9 (diff)
downloadhaskell-330e6e9c7a88d2be6d3f78eff44a9a6fcf9733a2.tar.gz
Documentation: use https links
-rwxr-xr-x.gitlab/linters/check-cpp.py1
-rw-r--r--docs/users_guide/bugs.rst8
-rw-r--r--docs/users_guide/codegens.rst10
-rw-r--r--docs/users_guide/debug-info.rst2
-rw-r--r--docs/users_guide/extending_ghc.rst4
-rw-r--r--docs/users_guide/exts/arrows.rst12
-rw-r--r--docs/users_guide/exts/concurrent.rst6
-rw-r--r--docs/users_guide/exts/data_kinds.rst2
-rw-r--r--docs/users_guide/exts/defer_type_errors.rst2
-rw-r--r--docs/users_guide/exts/gadt.rst8
-rw-r--r--docs/users_guide/exts/generics.rst6
-rw-r--r--docs/users_guide/exts/hiding_unexported.rst2
-rw-r--r--docs/users_guide/exts/monomorphism.rst2
-rw-r--r--docs/users_guide/exts/overloaded_strings.rst2
-rw-r--r--docs/users_guide/exts/pattern_guards.rst2
-rw-r--r--docs/users_guide/exts/poly_kinds.rst2
-rw-r--r--docs/users_guide/exts/pragmas.rst2
-rw-r--r--docs/users_guide/exts/quantified_constraints.rst6
-rw-r--r--docs/users_guide/exts/recursive_do.rst8
-rw-r--r--docs/users_guide/exts/roles.rst2
-rw-r--r--docs/users_guide/exts/scoped_type_variables.rst2
-rw-r--r--docs/users_guide/exts/static_pointers.rst2
-rw-r--r--docs/users_guide/exts/stm.rst2
-rw-r--r--docs/users_guide/exts/strict.rst6
-rw-r--r--docs/users_guide/exts/template_haskell.rst8
-rw-r--r--docs/users_guide/exts/type_families.rst6
-rw-r--r--docs/users_guide/exts/typeclasses.rst2
-rw-r--r--docs/users_guide/exts/view_patterns.rst4
-rw-r--r--docs/users_guide/ghci.rst2
-rw-r--r--docs/users_guide/intro.rst16
-rw-r--r--docs/users_guide/packages.rst14
-rw-r--r--docs/users_guide/profiling.rst4
-rw-r--r--docs/users_guide/runtime_control.rst6
-rw-r--r--docs/users_guide/separate_compilation.rst2
-rw-r--r--docs/users_guide/using-optimisation.rst4
-rw-r--r--docs/users_guide/utils.rst2
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.