diff options
Diffstat (limited to 'docs/users_guide')
35 files changed, 85 insertions, 85 deletions
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. |