xmonad.cabal: bump version number to 0.14.2 for release

I rather not trust other code that interprets that file to know how to strip
the white space before the commas.

.gitignore

@@ -1,14 +1,9 @@
-.cabal-sandbox/
-cabal.sandbox.config
 .hpc/
 *.hi
 *.o
 *.p_hi
 *.prof
 *.tix
-cabal.config
-dist
-dist-*
 
 # editor temp files
 
@@ -23,4 +18,12 @@ tags
 
 # stack artifacts
 /.stack-work/
+
+# cabal-install artifacts
+/.*.environment.*-*
+/.cabal-sandbox/
+/cabal.config
 /cabal.project.local
+/cabal.sandbox.config
+/dist-newstyle/
+/dist/

.travis.yml

@@ -2,7 +2,7 @@
 #
 #   runghc make_travis_yml_2.hs '-o' '.travis.yml' 'xmonad.cabal' 'libxrandr-dev'
 #
-# For more information, see https://github.com/hvr/multi-ghc-travis
+# For more information, see https://github.com/haskell-CI/haskell-ci
 #
 language: c
 sudo: false
@@ -28,6 +28,9 @@ before_cache:
 
 matrix:
   include:
+    - compiler: "ghc-8.6.1"
+      env: GHCHEAD=true
+      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-head,ghc-8.6.1,libxrandr-dev], sources: [hvr-ghc]}}
     - compiler: "ghc-8.4.3"
     # env: TEST=--disable-tests BENCH=--disable-benchmarks
       addons: {apt: {packages: [ghc-ppa-tools,cabal-install-2.2,ghc-8.4.3,libxrandr-dev], sources: [hvr-ghc]}}
@@ -37,15 +40,9 @@ matrix:
     - compiler: "ghc-8.0.2"
     # env: TEST=--disable-tests BENCH=--disable-benchmarks
       addons: {apt: {packages: [ghc-ppa-tools,cabal-install-2.2,ghc-8.0.2,libxrandr-dev], sources: [hvr-ghc]}}
-    - compiler: "ghc-7.10.3"
+
-    # env: TEST=--disable-tests BENCH=--disable-benchmarks
+  allow_failures:
-      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-2.2,ghc-7.10.3,libxrandr-dev], sources: [hvr-ghc]}}
+    - compiler: "ghc-8.6.1"
-    - compiler: "ghc-7.8.4"
-    # env: TEST=--disable-tests BENCH=--disable-benchmarks
-      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-2.2,ghc-7.8.4,libxrandr-dev], sources: [hvr-ghc]}}
-    - compiler: "ghc-7.6.3"
-    # env: TEST=--disable-tests BENCH=--disable-benchmarks
-      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-2.2,ghc-7.6.3,libxrandr-dev], sources: [hvr-ghc]}}
 
 before_install:
   - HC=${CC}
@@ -69,8 +66,27 @@ install:
   - travis_retry cabal update -v
   - "sed -i.bak 's/^jobs:/-- jobs:/' ${HOME}/.cabal/config"
   - rm -fv cabal.project cabal.project.local
+  # Overlay Hackage Package Index for GHC HEAD: https://github.com/hvr/head.hackage
+  - |
+    if $GHCHEAD; then
+      sed -i 's/-- allow-newer: .*/allow-newer: *:base/' ${HOME}/.cabal/config
+      for pkg in $($HCPKG list --simple-output); do pkg=$(echo $pkg | sed 's/-[^-]*$//'); sed -i "s/allow-newer: /allow-newer: *:$pkg, /" ${HOME}/.cabal/config; done
+
+      echo 'repository head.hackage'                                                        >> ${HOME}/.cabal/config
+      echo '   url: http://head.hackage.haskell.org/'                                       >> ${HOME}/.cabal/config
+      echo '   secure: True'                                                                >> ${HOME}/.cabal/config
+      echo '   root-keys: 07c59cb65787dedfaef5bd5f987ceb5f7e5ebf88b904bbd4c5cbdeb2ff71b740' >> ${HOME}/.cabal/config
+      echo '              2e8555dde16ebd8df076f1a8ef13b8f14c66bad8eafefd7d9e37d0ed711821fb' >> ${HOME}/.cabal/config
+      echo '              8f79fd2389ab2967354407ec852cbe73f2e8635793ac446d09461ffb99527f6e' >> ${HOME}/.cabal/config
+      echo '   key-threshold: 3'                                                            >> ${HOME}/.cabal.config
+
+      grep -Ev -- '^\s*--' ${HOME}/.cabal/config | grep -Ev '^\s*$'
+
+      cabal new-update head.hackage -v
+    fi
   - grep -Ev -- '^\s*--' ${HOME}/.cabal/config | grep -Ev '^\s*$'
   - "printf 'packages: \".\"\\n' > cabal.project"
+  - "if [ $HCNUMVER -lt 80600 ]; then printf 'package xmonad\\n  flags: +generatemanpage\n' >> cabal.project; fi"
   - touch cabal.project.local
   - "if ! $NOINSTALLEDCONSTRAINTS; then for pkg in $($HCPKG list --simple-output); do echo $pkg  | grep -vw -- xmonad | sed 's/^/constraints: /' | sed 's/-[^-]*$/ installed/' >> cabal.project.local; done; fi"
   - cat cabal.project || true
@@ -93,6 +109,7 @@ script:
   - cd ${DISTDIR} || false
   - find . -maxdepth 1 -name '*.tar.gz' -exec tar -xvf '{}' \;
   - "printf 'packages: xmonad-*/*.cabal\\n' > cabal.project"
+  - "if [ $HCNUMVER -lt 80600 ]; then printf 'package xmonad\\n  flags: +generatemanpage\n' >> cabal.project; fi"
   - touch cabal.project.local
   - "if ! $NOINSTALLEDCONSTRAINTS; then for pkg in $($HCPKG list --simple-output); do echo $pkg  | grep -vw -- xmonad | sed 's/^/constraints: /' | sed 's/-[^-]*$/ installed/' >> cabal.project.local; done; fi"
   - cat cabal.project || true

CHANGES.md

@@ -1,5 +1,39 @@
 # Change Log / Release Notes
 
+## unknown (unknown)
+
+## 0.14.1 (August 20, 2018)
+
+### Breaking Changes
+
+  * The cabal build no longer installs xmonad.hs, xmonad.1, and xmonad.1.html
+    as data files. The location cabal picks for chose files isn't useful as
+    standard tools like man(1) won't find them there. Instead, we rely on
+    distributors to pick up the files from the source tarball during the build
+    and to install them into proper locations where their users expect them.
+    [https://github.com/xmonad/xmonad/pull/127]
+
+### Bug Fixes
+
+  * Add support for GHC 8.6.x by providing an instance for 'MonadFail X'. A
+    side effect of that change is that our code no longer compiles with GHC
+    versions prior to 8.0.x. We could work around that, no doubt, but the
+    resulting code would require CPP and Cabal flags and whatnot. It feels more
+    reasonable to just require a moderately recent compiler instead of going
+    through all that trouble.
+
+  * xmonad no longer always recompile on startup. Now it only does so if the
+    executable does not have the name that would be used for the compilation
+    output. The purpose of recompiling and executing the results in this case is
+    so that the `xmonad` executable in the package can be used with custom
+    configurations.
+
+### Enhancements
+
+  * Whenever xmonad recompiles, it now explains how it is attempting to
+    recompile, by outputting logs to stderr. If you are using xmonad as a custom
+    X session, then this will end up in a `.xsession-errors` file.
+
 ## 0.14 (July 30, 2018)
 
 ### Bug Fixes
@@ -23,6 +57,7 @@
   * Restored compatability with GHC version prior to 8.0.1 by removing the
     dependency on directory version 1.2.3.
 
+
 ## 0.13 (February 10, 2017)
 
 ### Breaking Changes

README.md

@@ -60,7 +60,15 @@ We'll now walk through the complete list of toolchain dependencies.
     library headers. On many platforms, these come pre-installed. For
     others, such as Debian, you can get them from your package manager:
 
-        $ apt-get install libx11-dev libxinerama-dev libxext-dev
+        # for xmonad
+        $ apt-get install libx11-dev libxinerama-dev libxext-dev libxrandr-dev libxss-dev
+
+        # for xmonad-contrib
+        $ apt-get install libxft-dev
+
+Then build and install with:
+
+    $ cabal install
 
 ## Running xmonad
 

man/xmonad.1

@@ -1,10 +1,10 @@
-.TH xmonad 1 "31 December 2012" xmonad-0.13 "xmonad manual".\" Automatically generated by Pandoc 1.19.2.1
+.\" Automatically generated by Pandoc 2.2.1
 .\"
-.TH "" "" "" "" ""
+.TH "XMONAD" "1" "20 August 2018" "Tiling Window Manager" ""
 .hy
 .SH Name
 .PP
-xmonad \- a tiling window manager
+xmonad \- Tiling Window Manager
 .SH Description
 .PP
 \f[I]xmonad\f[] is a minimalist tiling window manager for X, written in
@@ -41,7 +41,7 @@ A benefit of this is that the code is simple to understand, and easy to
 modify.
 .SH Usage
 .PP
-\f[I]xmonad\f[] places each window into a "workspace".
+\f[I]xmonad\f[] places each window into a \[lq]workspace\[rq].
 Each workspace can have any number of windows, which you can cycle
 though with mod\-j and mod\-k.
 Windows are either displayed full screen, tiled horizontally, or tiled
@@ -67,31 +67,32 @@ and visible workspaces are swapped.
 xmonad has several flags which you may pass to the executable.
 These flags are:
 .TP
-.B \-\-recompile
+.B \[en]recompile
 Recompiles your configuration in \f[I]~/.xmonad/xmonad.hs\f[]
 .RS
 .RE
 .TP
-.B \-\-restart
+.B \[en]restart
 Causes the currently running \f[I]xmonad\f[] process to restart
 .RS
 .RE
 .TP
-.B \-\-replace
+.B \[en]replace
 Replace the current window manager with xmonad
 .RS
 .RE
 .TP
-.B \-\-version
+.B \[en]version
 Display version of \f[I]xmonad\f[]
 .RS
 .RE
 .TP
-.B \-\-verbose\-version
+.B \[en]verbose\-version
 Display detailed version of \f[I]xmonad\f[]
 .RS
 .RE
-.SS Default keyboard bindings
+.PP
+##Default keyboard bindings
 .TP
 .B mod\-shift\-return
 Launch terminal
@@ -209,6 +210,12 @@ beginners)
 .RS
 .RE
 .TP
+.B mod\-question
+Run xmessage with a summary of the default keybindings (useful for
+beginners)
+.RS
+.RE
+.TP
 .B mod\-[1..9]
 Switch to workspace N
 .RS
@@ -262,7 +269,7 @@ xmonad.org (http://xmonad.org).
 .SS Modular Configuration
 .PP
 As of \f[I]xmonad\-0.9\f[], any additional Haskell modules may be placed
-in \f[I]~/.xmonad/lib/\f[] are available in GHC\[aq]s searchpath.
+in \f[I]~/.xmonad/lib/\f[] are available in GHC's searchpath.
 Hierarchical modules are supported: for example, the file
 \f[I]~/.xmonad/lib/XMonad/Stack/MyAdditions.hs\f[] could contain:
 .IP

man/xmonad.1.html

@@ -1,21 +1,97 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang="">
 <head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+  <meta charset="utf-8" />
-  <meta http-equiv="Content-Style-Type" content="text/css" />
   <meta name="generator" content="pandoc" />
-  <title></title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
-  <style type="text/css">code{white-space: pre;}</style>
+  <meta name="author" content="" />
+  <meta name="dcterms.date" content="2018-08-20" />
+  <title>XMONAD(1) Tiling Window Manager</title>
+  <style type="text/css">
+      code{white-space: pre-wrap;}
+      span.smallcaps{font-variant: small-caps;}
+      span.underline{text-decoration: underline;}
+      div.column{display: inline-block; vertical-align: top; width: 50%;}
+  </style>
+  <style type="text/css">
+a.sourceLine { display: inline-block; line-height: 1.25; }
+a.sourceLine { pointer-events: none; color: inherit; text-decoration: inherit; }
+a.sourceLine:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode { white-space: pre; position: relative; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+code.sourceCode { white-space: pre-wrap; }
+a.sourceLine { text-indent: -1em; padding-left: 1em; }
+}
+pre.numberSource a.sourceLine
+  { position: relative; left: -4em; }
+pre.numberSource a.sourceLine::before
+  { content: attr(data-line-number);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; pointer-events: all; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  }
+@media screen {
+a.sourceLine::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } /* Alert */
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #7d9029; } /* Attribute */
+code span.bn { color: #40a070; } /* BaseN */
+code span.bu { } /* BuiltIn */
+code span.cf { color: #007020; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4070a0; } /* Char */
+code span.cn { color: #880000; } /* Constant */
+code span.co { color: #60a0b0; font-style: italic; } /* Comment */
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #ba2121; font-style: italic; } /* Documentation */
+code span.dt { color: #902000; } /* DataType */
+code span.dv { color: #40a070; } /* DecVal */
+code span.er { color: #ff0000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #40a070; } /* Float */
+code span.fu { color: #06287e; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #007020; font-weight: bold; } /* Keyword */
+code span.op { color: #666666; } /* Operator */
+code span.ot { color: #007020; } /* Other */
+code span.pp { color: #bc7a00; } /* Preprocessor */
+code span.sc { color: #4070a0; } /* SpecialChar */
+code span.ss { color: #bb6688; } /* SpecialString */
+code span.st { color: #4070a0; } /* String */
+code span.va { color: #19177c; } /* Variable */
+code span.vs { color: #4070a0; } /* VerbatimString */
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */
+  </style>
+  <!--[if lt IE 9]>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
+  <![endif]-->
 </head>
 <body>
-<h1>xmonad-0.13</h1><p>Section: xmonad manual (1)<br/>Updated: 31 December 2012</p><hr/>
+<header>
-<div id="TOC">
+<h1 class="title">XMONAD(1) Tiling Window Manager</h1>
+<p class="author"></p>
+<p class="date">20 August 2018</p>
+</header>
+<nav id="TOC">
 <ul>
 <li><a href="#name">Name</a></li>
 <li><a href="#description">Description</a></li>
 <li><a href="#usage">Usage</a><ul>
 <li><a href="#flags">Flags</a></li>
-<li><a href="#default-keyboard-bindings">Default keyboard bindings</a></li>
 </ul></li>
 <li><a href="#examples">Examples</a></li>
 <li><a href="#customization">Customization</a><ul>
@@ -23,37 +99,37 @@
 </ul></li>
 <li><a href="#bugs">Bugs</a></li>
 </ul>
-</div>
+</nav>
 <h1 id="name">Name</h1>
-<p>xmonad - a tiling window manager</p>
+<p>xmonad - Tiling Window Manager</p>
 <h1 id="description">Description</h1>
 <p><em>xmonad</em> is a minimalist tiling window manager for X, written in Haskell. Windows are managed using automatic layout algorithms, which can be dynamically reconfigured. At any time windows are arranged so as to maximize the use of screen real estate. All features of the window manager are accessible purely from the keyboard: a mouse is entirely optional. <em>xmonad</em> is configured in Haskell, and custom layout algorithms may be implemented by the user in config files. A principle of <em>xmonad</em> is predictability: the user should know in advance precisely the window arrangement that will result from any action.</p>
 <p>By default, <em>xmonad</em> provides three layout algorithms: tall, wide and fullscreen. In tall or wide mode, windows are tiled and arranged to prevent overlap and maximize screen use. Sets of windows are grouped together on virtual screens, and each screen retains its own layout, which may be reconfigured dynamically. Multiple physical monitors are supported via Xinerama, allowing simultaneous display of a number of screens.</p>
 <p>By utilizing the expressivity of a modern functional language with a rich static type system, <em>xmonad</em> provides a complete, featureful window manager in less than 1200 lines of code, with an emphasis on correctness and robustness. Internal properties of the window manager are checked using a combination of static guarantees provided by the type system, and type-based automated testing. A benefit of this is that the code is simple to understand, and easy to modify.</p>
 <h1 id="usage">Usage</h1>
-<p><em>xmonad</em> places each window into a &quot;workspace&quot;. Each workspace can have any number of windows, which you can cycle though with mod-j and mod-k. Windows are either displayed full screen, tiled horizontally, or tiled vertically. You can toggle the layout mode with mod-space, which will cycle through the available modes.</p>
+<p><em>xmonad</em> places each window into a “workspace”. Each workspace can have any number of windows, which you can cycle though with mod-j and mod-k. Windows are either displayed full screen, tiled horizontally, or tiled vertically. You can toggle the layout mode with mod-space, which will cycle through the available modes.</p>
 <p>You can switch to workspace N with mod-N. For example, to switch to workspace 5, you would press mod-5. Similarly, you can move the current window to another workspace with mod-shift-N.</p>
 <p>When running with multiple monitors (Xinerama), each screen has exactly 1 workspace visible. mod-{w,e,r} switch the focus between screens, while shift-mod-{w,e,r} move the current window to that screen. When <em>xmonad</em> starts, workspace 1 is on screen 1, workspace 2 is on screen 2, etc. When switching workspaces to one that is already visible, the current and visible workspaces are swapped.</p>
 <h2 id="flags">Flags</h2>
 <p>xmonad has several flags which you may pass to the executable. These flags are:</p>
 <dl>
-<dt>--recompile</dt>
+<dt>–recompile</dt>
 <dd>Recompiles your configuration in <em>~/.xmonad/xmonad.hs</em>
 </dd>
-<dt>--restart</dt>
+<dt>–restart</dt>
 <dd>Causes the currently running <em>xmonad</em> process to restart
 </dd>
-<dt>--replace</dt>
+<dt>–replace</dt>
 <dd>Replace the current window manager with xmonad
 </dd>
-<dt>--version</dt>
+<dt>–version</dt>
 <dd>Display version of <em>xmonad</em>
 </dd>
-<dt>--verbose-version</dt>
+<dt>–verbose-version</dt>
 <dd>Display detailed version of <em>xmonad</em>
 </dd>
 </dl>
-<h2 id="default-keyboard-bindings">Default keyboard bindings</h2>
+<p>##Default keyboard bindings</p>
 <dl>
 <dt>mod-shift-return</dt>
 <dd>Launch terminal
@@ -124,6 +200,9 @@
 <dt>mod-shift-slash</dt>
 <dd>Run xmessage with a summary of the default keybindings (useful for beginners)
 </dd>
+<dt>mod-question</dt>
+<dd>Run xmessage with a summary of the default keybindings (useful for beginners)
+</dd>
 <dt>mod-[1..9]</dt>
 <dd>Switch to workspace N
 </dd>
@@ -155,9 +234,9 @@
 <p>xmonad is customized in ~/.xmonad/xmonad.hs, and then restarted with mod-q.</p>
 <p>You can find many extensions to the core feature set in the xmonad- contrib package, available through your package manager or from <a href="http://xmonad.org">xmonad.org</a>.</p>
 <h2 id="modular-configuration">Modular Configuration</h2>
-<p>As of <em>xmonad-0.9</em>, any additional Haskell modules may be placed in <em>~/.xmonad/lib/</em> are available in GHC's searchpath. Hierarchical modules are supported: for example, the file <em>~/.xmonad/lib/XMonad/Stack/MyAdditions.hs</em> could contain:</p>
+<p>As of <em>xmonad-0.9</em>, any additional Haskell modules may be placed in <em>~/.xmonad/lib/</em> are available in GHC’s searchpath. Hierarchical modules are supported: for example, the file <em>~/.xmonad/lib/XMonad/Stack/MyAdditions.hs</em> could contain:</p>
-<pre class="haskell"><code>module XMonad.Stack.MyAdditions (function1) where
+<div class="sourceCode" id="cb1"><pre class="sourceCode haskell"><code class="sourceCode haskell"><a class="sourceLine" id="cb1-1" data-line-number="1"><span class="kw">module</span> <span class="dt">XMonad.Stack.MyAdditions</span> (function1) <span class="kw">where</span></a>
-  function1 = error &quot;function1: Not implemented yet!&quot;</code></pre>
+<a class="sourceLine" id="cb1-2" data-line-number="2">  function1 <span class="fu">=</span> error <span class="st">&quot;function1: Not implemented yet!&quot;</span></a></code></pre></div>
 <p>Your xmonad.hs may then import XMonad.Stack.MyAdditions as if that module was contained within xmonad or xmonad-contrib.</p>
 <h1 id="bugs">Bugs</h1>
 <p>Probably. If you find any, please report them to the <a href="https://github.com/xmonad/xmonad/issues">bugtracker</a></p>

man/xmonad.1.markdown

@@ -1,7 +1,12 @@
-#Name
+% XMONAD(1) Tiling Window Manager
-xmonad - a tiling window manager
+%
+% 20 August 2018
 
-#Description
+# Name
+
+xmonad - Tiling Window Manager
+
+# Description
 
 _xmonad_ is a minimalist tiling window manager for X, written in Haskell.
 Windows are managed using automatic layout algorithms, which can be
@@ -28,7 +33,7 @@ combination of static guarantees provided by the type system, and
 type-based automated testing. A benefit of this is that the code is simple
 to understand, and easy to modify.
 
-#Usage
+# Usage
 
 _xmonad_ places each window into a "workspace". Each workspace can have
 any number of windows, which you can cycle though with mod-j and mod-k.
@@ -47,7 +52,8 @@ starts, workspace 1 is on screen 1, workspace 2 is on screen 2, etc. When
 switching workspaces to one that is already visible, the current and
 visible workspaces are swapped.
 
-##Flags
+## Flags
+
 xmonad  has  several flags which  you may pass to the executable.
 These flags are:
 
@@ -70,12 +76,13 @@ These flags are:
 
 ___KEYBINDINGS___
 
-#Examples
+# Examples
+
 To use xmonad as your window manager add to your _~/.xinitrc_ file:
 
 > exec xmonad
 
-#Customization
+# Customization
 xmonad is customized in ~/.xmonad/xmonad.hs, and then restarted
 with mod-q.
 
@@ -83,7 +90,7 @@ You can find many extensions to the core feature set in the xmonad-
 contrib package, available through your  package  manager  or  from
 [xmonad.org].
 
-##Modular Configuration
+## Modular Configuration
 As of _xmonad-0.9_, any additional Haskell modules may be placed in
 _~/.xmonad/lib/_ are available in GHC's searchpath. Hierarchical modules
 are supported: for example, the file
@@ -97,7 +104,7 @@ module XMonad.Stack.MyAdditions (function1) where
 Your xmonad.hs may then import XMonad.Stack.MyAdditions as if that
 module was contained within xmonad or xmonad-contrib.
 
-#Bugs
+# Bugs
 Probably. If you find any, please report them to the [bugtracker]
 
 [xmonad.org]: http://xmonad.org

src/XMonad/Config.hs

@@ -221,9 +221,9 @@ keys conf@(XConfig {XMonad.modMask = modMask}) = M.fromList $
     , ((modMask .|. shiftMask, xK_q     ), io (exitWith ExitSuccess)) -- %! Quit xmonad
     , ((modMask              , xK_q     ), spawn "if type xmonad; then xmonad --recompile && xmonad --restart; else xmessage xmonad not in \\$PATH: \"$PATH\"; fi") -- %! Restart xmonad
 
-    , ((modMask .|. shiftMask, xK_slash ), helpCommand)
+    , ((modMask .|. shiftMask, xK_slash ), helpCommand) -- %! Run xmessage with a summary of the default keybindings (useful for beginners)
     -- repeat the binding for non-American layout keyboards
-    , ((modMask              , xK_question), helpCommand)
+    , ((modMask              , xK_question), helpCommand) -- %! Run xmessage with a summary of the default keybindings (useful for beginners)
     ]
     ++
     -- mod-[1..9] %! Switch to workspace N
@@ -239,7 +239,7 @@ keys conf@(XConfig {XMonad.modMask = modMask}) = M.fromList $
         , (f, m) <- [(W.view, 0), (W.shift, shiftMask)]]
   where
     helpCommand :: X ()
-    helpCommand = spawn ("echo " ++ show help ++ " | xmessage -file -")  -- %! Run xmessage with a summary of the default keybindings (useful for beginners)
+    helpCommand = spawn ("echo " ++ show help ++ " | xmessage -file -")
 
 -- | Mouse bindings: default actions bound to mouse events
 mouseBindings :: XConfig Layout -> M.Map (KeyMask, Button) (Window -> X ())

src/XMonad/Core.hs

@@ -1,5 +1,5 @@
 {-# LANGUAGE ExistentialQuantification, FlexibleInstances, GeneralizedNewtypeDeriving,
-             MultiParamTypeClasses, TypeSynonymInstances, CPP, DeriveDataTypeable #-}
+             MultiParamTypeClasses, TypeSynonymInstances, DeriveDataTypeable #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -36,7 +36,8 @@ import XMonad.StackSet hiding (modify)
 import Prelude
 import Control.Exception.Extensible (fromException, try, bracket, throw, finally, SomeException(..))
 import qualified Control.Exception.Extensible as E
-import Control.Applicative
+import Control.Applicative(Applicative, pure, (<$>), (<*>))
+import Control.Monad.Fail
 import Control.Monad.State
 import Control.Monad.Reader
 import Data.Semigroup
@@ -147,7 +148,7 @@ data ScreenDetail   = SD { screenRect :: !Rectangle } deriving (Eq,Show, Read)
 -- instantiated on 'XConf' and 'XState' automatically.
 --
 newtype X a = X (ReaderT XConf (StateT XState IO) a)
-    deriving (Functor, Monad, MonadIO, MonadState XState, MonadReader XConf, Typeable)
+    deriving (Functor, Monad, MonadFail, MonadIO, MonadState XState, MonadReader XConf, Typeable)
 
 instance Applicative X where
   pure = return
@@ -606,9 +607,36 @@ recompile force = io $ do
 
     useBuildscript <- do
       exists <- doesFileExist buildscript
-      if exists then isExecutable buildscript else return False
+      if exists
+        then do
+          isExe <- isExecutable buildscript
+          if isExe
+            then do
+              trace $ "XMonad will use build script at " ++ show buildscript ++ " to recompile."
+              return True
+            else do
+              trace $ unlines
+                [ "XMonad will not use build script, because " ++ show buildscript ++ " is not executable."
+                , "Suggested resolution to use it: chmod u+x " ++ show buildscript
+                ]
+              return False
+        else do
+          trace $
+            "XMonad will use ghc to recompile, because " ++ show buildscript ++ " does not exist."
+          return False
 
-    if force || useBuildscript || any (binT <) (srcT : libTs)
+    shouldRecompile <-
+      if useBuildscript || force
+        then return True
+        else if any (binT <) (srcT : libTs)
+          then do
+            trace "XMonad doing recompile because some files have changed."
+            return True
+          else do
+            trace "XMonad skipping recompile because it is not forced (e.g. via --recompile), and neither xmonad.hs nor any *.hs / *.lhs / *.hsc files in lib/ have been changed."
+            return False
+
+    if shouldRecompile
       then do
         -- temporarily disable SIGCHLD ignoring:
         uninstallSignalHandlers
@@ -621,17 +649,19 @@ recompile force = io $ do
         installSignalHandlers
 
         -- now, if it fails, run xmessage to let the user know:
-        when (status /= ExitSuccess) $ do
+        if status == ExitSuccess
-            ghcErr <- readFile err
+            then trace "XMonad recompilation process exited with success!"
-            let msg = unlines $
+            else do
-                    ["Error detected while loading xmonad configuration file: " ++ src]
+                ghcErr <- readFile err
-                    ++ lines (if null ghcErr then show status else ghcErr)
+                let msg = unlines $
-                    ++ ["","Please check the file for errors."]
+                        ["Error detected while loading xmonad configuration file: " ++ src]
-            -- nb, the ordering of printing, then forking, is crucial due to
+                        ++ lines (if null ghcErr then show status else ghcErr)
-            -- lazy evaluation
+                        ++ ["","Please check the file for errors."]
-            hPutStrLn stderr msg
+                -- nb, the ordering of printing, then forking, is crucial due to
-            forkProcess $ executeFile "xmessage" True ["-default", "okay", replaceUnicode msg] Nothing
+                -- lazy evaluation
-            return ()
+                hPutStrLn stderr msg
+                forkProcess $ executeFile "xmessage" True ["-default", "okay", replaceUnicode msg] Nothing
+                return ()
         return (status == ExitSuccess)
       else return True
  where getModTime f = E.catch (Just <$> getModificationTime f) (\(SomeException _) -> return Nothing)

src/XMonad/Main.hs

@@ -113,12 +113,18 @@ usage = do
 --
 buildLaunch ::  IO ()
 buildLaunch = do
-    recompile False
-    dir  <- getXMonadDataDir
-    args <- getArgs
     whoami <- getProgName
     let compiledConfig = "xmonad-"++arch++"-"++os
-    unless (whoami == compiledConfig) $
+    unless (whoami == compiledConfig) $ do
+      trace $ concat
+        [ "XMonad is recompiling and replacing itself another XMonad process because the current process is called "
+        , show whoami
+        , " but the compiled configuration should be called "
+        , show compiledConfig
+        ]
+      recompile False
+      dir  <- getXMonadDataDir
+      args <- getArgs
       executeFile (dir </> compiledConfig) False args Nothing
 
 sendRestart :: IO ()
@@ -197,7 +203,6 @@ launch initxmc = do
     hSetBuffering stdout NoBuffering
 
     let layout = layoutHook xmc
-        lreads = readsLayout layout
         initialWinset = let padToLen n xs = take (max n (length xs)) $ xs ++ repeat ""
             in new layout (padToLen (length xinesc) (workspaces xmc)) $ map SD xinesc
 
@@ -473,7 +478,7 @@ grabKeys = do
          forM_ (keysymToKeycodes sym) $ \kc ->
               mapM_ (grab kc . (mask .|.)) =<< extraModifiers
 
--- | XXX comment me
+-- | Grab the buttons
 grabButtons :: X ()
 grabButtons = do
     XConf { display = dpy, theRoot = rootw } <- ask

src/XMonad/Operations.hs

@@ -28,7 +28,7 @@ import Data.Ratio
 import qualified Data.Map as M
 import qualified Data.Set as S
 
-import Control.Applicative
+import Control.Applicative((<$>), (<*>))
 import Control.Arrow (second)
 import Control.Monad.Reader
 import Control.Monad.State

util/GenerateManpage.hs

@@ -1,57 +1,85 @@
 {-# LANGUAGE FlexibleContexts #-}
+
+-- Generates a in-memory version of "man/xmonad.1.markdown" that has the list
+-- of known key-bindings is inserted automatically from "Config.hs". That
+-- document is then rendered with Pandoc as "man/xmonad.1" and
+-- "man/xmonad.1.html".
+--
 -- Unlike the rest of xmonad, this file is released under the GNU General
 -- Public License version 2 or later.
 
---
+import Control.Monad.IO.Class (liftIO)
--- Generates man/xmonad.1 from man/xmonad.1.in by filling the list of
--- keybindings with values scraped from Config.hs
---
--- Uses cabal to grab the xmonad version from xmonad.cabal
---
--- Uses pandoc to convert the "xmonad.1.markdown" to "xmonad.1"
---
--- Format for the docstrings in Config.hs takes the following form:
---
--- -- mod-x %! Frob the whatsit
---
--- "Frob the whatsit" will be used as the description for keybinding "mod-x"
---
--- If the keybinding name is omitted, it will try to guess from the rest of the
--- line. For example:
---
--- [ ((modMask .|. shiftMask, xK_Return), spawn "xterm") -- %! Launch an xterm
---
--- Here, mod-shift-return will be used as the keybinding name.
-import Control.Monad
-import Control.Applicative
-import Text.Regex.Posix
 import Data.Char
 import Data.List
+import qualified Data.Text as T
+import qualified Data.Text.IO as TIO
+import Text.Pandoc
+import Text.Regex.Posix
 
-import Distribution.PackageDescription.Parse
+main :: IO ()
-import Distribution.Verbosity
+main = do
-import Distribution.Package
+    keybindings <- guessBindings
-import Distribution.PackageDescription
-import Text.PrettyPrint.HughesPJ
-import Distribution.Text
 
-import Text.Pandoc -- works with 1.15.x
+    markdownSource <- readFile "./man/xmonad.1.markdown"
 
-releaseDate = "31 December 2012"
+    runIOorExplode $ do
+        parsed <- readMarkdown (def { readerStandalone = True, readerExtensions = pandocExtensions })
+            . T.pack
+            . unlines
+            . replace "___KEYBINDINGS___" keybindings
+            . lines
+            $ markdownSource
 
-trim :: String -> String
+        manTemplate <- getDefaultTemplate "man"
-trim = reverse . dropWhile isSpace . reverse . dropWhile isSpace
+        manBody <- writeMan def { writerTemplate = Just manTemplate } parsed
+        liftIO $ TIO.writeFile "./man/xmonad.1" $ manBody
+        liftIO $ putStrLn "Documentation created: man/xmonad.1"
 
-guessKeys line = concat $ intersperse "-" (modifiers ++ [map toLower key])
+        htmltemplate <- getDefaultTemplate "html"
-    where modifiers = map (!!1) (line =~ "(mod|shift|control)Mask")
+        htmlBody <- writeHtml5String def
-          (_, _, _, [key]) = line =~ "xK_([_[:alnum:]]+)" :: (String, String, String, [String])
+                                     { writerTemplate = Just htmltemplate
+                                     , writerTableOfContents = True }
+                                     parsed
+        liftIO $ TIO.writeFile "./man/xmonad.1.html" htmlBody
+        liftIO $ putStrLn "Documentation created: man/xmonad.1.html"
+
+-- | The format for the docstrings in "Config.hs" takes the following form:
+--
+-- @
+--   -- mod-x %! Frob the whatsit
+-- @
+--
+-- "Frob the whatsit" will be used as the description for keybinding "mod-x".--
+-- If the name of the key binding is omitted, the function tries to guess it
+-- from the rest of the line. For example:
+--
+-- @
+--   [ ((modMask .|. shiftMask, xK_Return), spawn "xterm") -- %! Launch an xterm
+-- @
+--
+-- Here, "mod-shift-return" will be used as the key binding name.
+
+guessBindings :: IO String
+guessBindings = do
+  buf <- readFile "./src/XMonad/Config.hs"
+  return (intercalate "\n\n" (map markdownDefn (allBindings buf)))
+
+allBindings :: String -> [(String, String)]
+allBindings xs = map (binding . map trim) (xs =~ "(.*)--(.*)%!(.*)")
 
 binding :: [String] -> (String, String)
 binding [ _, bindingLine, "", desc ] = (guessKeys bindingLine, desc)
 binding [ _, _, keyCombo, desc ] = (keyCombo, desc)
+binding x = error ("binding: called with unexpected argument " ++ show x)
 
-allBindings :: String -> [(String, String)]
+guessKeys :: String -> String
-allBindings xs = map (binding . map trim) (xs =~ "(.*)--(.*)%!(.*)")
+guessKeys line =
+  case keys of
+    [key] -> concat $ intersperse "-" (modifiers ++ [map toLower key])
+    _     -> error ("guessKeys: unexpected number of keys " ++ show keys)
+  where
+    modifiers = map (!!1) (line =~ "(mod|shift|control)Mask")
+    (_, _, _, keys) = line =~ "xK_([_[:alnum:]]+)" :: (String, String, String, [String])
 
 -- FIXME: What escaping should we be doing on these strings?
 markdownDefn :: (String, String) -> String
@@ -60,39 +88,5 @@ markdownDefn (key, desc) = key ++ "\n:     " ++ desc
 replace :: Eq a => a -> a -> [a] -> [a]
 replace x y = map (\a -> if a == x then y else a)
 
--- rawSystem "pandoc" ["--read=markdown","--write=man","man/xmonad.1.markdown"]
+trim :: String -> String
-
+trim = reverse . dropWhile isSpace . reverse . dropWhile isSpace
-main = do
-    releaseName <- (show . disp . package . packageDescription)
-                    `liftM`readPackageDescription normal "xmonad.cabal"
-    keybindings <- (intercalate "\n\n" . map markdownDefn . allBindings)
-                    `liftM` readFile "./src/XMonad/Config.hs"
-
-    let manHeader = unwords [".TH xmonad 1","\""++releaseDate++"\"",releaseName,"\"xmonad manual\""]
-
-    Right parsed <- readMarkdown def
-        . unlines
-        . replace "___KEYBINDINGS___" keybindings
-        . lines
-        <$> readFile "./man/xmonad.1.markdown"
-
-    Right template <- getDefaultTemplate Nothing "man"
-    writeFile "./man/xmonad.1"
-        . (manHeader ++)
-        . writeMan def{ writerTemplate = Just template }
-        $ parsed
-    putStrLn "Documentation created: man/xmonad.1"
-
-    Right template <- getDefaultTemplate Nothing "html"
-    writeFile "./man/xmonad.1.html"
-        . writeHtmlString def
-            { writerVariables =
-                        [("include-before"
-                            ,"<h1>"++releaseName++"</h1>"++
-                             "<p>Section: xmonad manual (1)<br/>"++
-                             "Updated: "++releaseDate++"</p>"++
-                             "<hr/>")]
-            , writerTemplate = Just template
-            , writerTableOfContents = True }
-        $ parsed
-    putStrLn "Documentation created: man/xmonad.1.html"

xmonad.cabal

@@ -1,126 +1,127 @@
 name:               xmonad
-version:            0.14
+version:            0.14.2
-homepage:           http://xmonad.org
 synopsis:           A tiling window manager
-description:
+description:        xmonad is a tiling window manager for X. Windows are arranged
-    xmonad is a tiling window manager for X. Windows are arranged
+                    automatically to tile the screen without gaps or overlap, maximising
-    automatically to tile the screen without gaps or overlap, maximising
+                    screen use. All features of the window manager are accessible from the
-    screen use. All features of the window manager are accessible from
+                    keyboard: a mouse is strictly optional. xmonad is written and
-    the keyboard: a mouse is strictly optional. xmonad is written and
+                    extensible in Haskell. Custom layout algorithms, and other extensions,
-    extensible in Haskell. Custom layout algorithms, and other
+                    may be written by the user in config files. Layouts are applied
-    extensions, may be written by the user in config files. Layouts are
+                    dynamically, and different layouts may be used on each workspace.
-    applied dynamically, and different layouts may be used on each
+                    Xinerama is fully supported, allowing windows to be tiled on several
-    workspace. Xinerama is fully supported, allowing windows to be tiled
+                    screens.
-    on several screens.
-category:           System
 license:            BSD3
 license-file:       LICENSE
-author:             Spencer Janssen
+author:             Spencer Janssen, Don Stewart, Adam Vogt, David Roundy, Jason Creighton,
+                    Brent Yorgey, Peter Jones, Peter Simons, Andrea Rossato, Devin Mullins,
+                    Lukas Mai, Alec Berryman, Stefan O'Rear, Daniel Wagner, Peter J. Jones,
+                    Daniel Schoepe, Karsten Schoelzel, Neil Mitchell, Joachim Breitner,
+                    Peter De Wachter, Eric Mertens, Geoff Reedy, Michiel Derhaeg,
+                    Philipp Balzarek, Valery V. Vorotyntsev, Alex Tarkovsky, Fabian Beuke,
+                    Felix Hirn, Michael Sloan, Tomas Janousek, Vanessa McHale, Nicolas Pouillard,
+                    Aaron Denney, Austin Seipp, Benno Fünfstück, Brandon S Allbery, Chris Mears,
+                    Christian Thiemann, Clint Adams, Daniel Neri, David Lazar, Ferenc Wagner,
+                    Francesco Ariis, Gábor Lipták, Ivan N. Veselov, Ivan Tarasov, Javran Cheng,
+                    Jens Petersen, Joey Hess, Jonne Ransijn, Josh Holland, Khudyakov Alexey,
+                    Klaus Weidner, Michael G. Sloan, Mikkel Christiansen, Nicolas Dudebout,
+                    Ondřej Súkup, Paul Hebble, Shachaf Ben-Kiki, Siim Põder, Tim McIver,
+                    Trevor Elliott, Wouter Swierstra, Conrad Irwin, Tim Thelion
 maintainer:         xmonad@haskell.org
-extra-source-files: README.md CHANGES.md CONFIG STYLE
+tested-with:        GHC == 8.0.2, GHC == 8.2.2, GHC == 8.4.3, GHC == 8.6.1
+category:           System
+homepage:           http://xmonad.org
+bug-reports:        https://github.com/xmonad/xmonad/issues
+build-type:         Simple
+extra-source-files: README.md
+                    CHANGES.md
+                    CONFIG
+                    STYLE
                     tests/*.hs
                     tests/Properties/*.hs
                     tests/Properties/Layout/*.hs
-                    man/xmonad.1.markdown man/xmonad.1 man/xmonad.1.html
+                    man/xmonad.1.markdown
+                    man/xmonad.1
+                    man/xmonad.1.html
+                    man/xmonad.hs
                     util/GenerateManpage.hs
                     util/hpcReport.sh
 cabal-version:      >= 1.8
-bug-reports:        https://github.com/xmonad/xmonad/issues
-build-type:         Simple
-
-tested-with:
-                    GHC==7.6.3,
-                    GHC==7.8.4,
-                    GHC==7.10.3,
-                    GHC==8.0.2,
-                    GHC==8.2.2,
-                    GHC==8.4.3
-
-data-files:         man/xmonad.hs, man/xmonad.1, man/xmonad.1.html
 
 source-repository head
   type:     git
   location: https://github.com/xmonad/xmonad
 
 flag testing
-    description: Testing mode, only build minimal components
+  default:     False
-    default: False
+  manual:      True
-    manual: True
+  description: Testing mode, only build minimal components
 
 flag generatemanpage
-    description: Build the tool for generating the man page
+  default:     False
-    default: False
+  manual:      True
-    manual: True
+  description: Build the tool for generating the man page
 
 library
-    hs-source-dirs:     src
+  exposed-modules: XMonad
-    exposed-modules:    XMonad
+                   XMonad.Config
-                        XMonad.Main
+                   XMonad.Core
-                        XMonad.Core
+                   XMonad.Layout
-                        XMonad.Config
+                   XMonad.Main
-                        XMonad.Layout
+                   XMonad.ManageHook
-                        XMonad.ManageHook
+                   XMonad.Operations
-                        XMonad.Operations
+                   XMonad.StackSet
-                        XMonad.StackSet
+  other-modules:   Paths_xmonad
-    other-modules:      Paths_xmonad
+  hs-source-dirs:  src
+  build-depends:   base                  >= 4.9 && < 5
+                 , X11                   >= 1.8 && < 1.10
+                 , containers
+                 , data-default
+                 , directory
+                 , extensible-exceptions
+                 , filepath
+                 , mtl
+                 , process
+                 , setlocale
+                 , unix
+                 , utf8-string           >= 0.3 && < 1.1
+  ghc-options:     -funbox-strict-fields -Wall -fno-warn-unused-do-bind
 
-    build-depends: base < 5 && >=3,
+  if flag(testing)
-                   containers,
+    buildable: False
-                   data-default,
-                   directory,
-                   extensible-exceptions,
-                   filepath,
-                   setlocale,
-                   mtl,
-                   process,
-                   unix,
-                   utf8-string >= 0.3 && < 1.1,
-                   X11>=1.8 && < 1.10,
-                   semigroups
-
-    if true
-        ghc-options:        -funbox-strict-fields -Wall
-
-    if impl(ghc >= 6.12.1)
-        ghc-options:        -fno-warn-unused-do-bind
-    if impl(ghc < 7.0.0)
-        extensions: UndecidableInstances
-        -- needed for XMonad.Config's instance Default (XConfig a)
-    if flag(testing)
-        buildable: False
 
 executable xmonad
-    main-is:        Main.hs
+  main-is:       Main.hs
-    build-depends:  base,
+  build-depends: base, X11, mtl, unix, xmonad
-                    mtl,
+  ghc-options:   -Wall -fno-warn-unused-do-bind
-                    unix,
-                    X11,
-                    xmonad
-    ghc-options:    -Wall
-    if impl(ghc >= 6.12.1)
-        ghc-options:  -Wall -fno-warn-unused-do-bind
 
 executable generatemanpage
-    main-is: GenerateManpage.hs
+  main-is:        GenerateManpage.hs
-    hs-source-dirs: util
+  hs-source-dirs: util
-    if flag(generatemanpage)
-        build-depends: base,
-                       Cabal,
-                       pandoc,
-                       pretty,
-                       regex-posix
-    else
-        buildable: False
 
+  if flag(generatemanpage)
+    build-depends: base, pandoc >= 2, regex-posix, text
+  else
+    buildable: False
 
--- note util/hpcReport.sh
 test-suite properties
-    type: exitcode-stdio-1.0
+  type:           exitcode-stdio-1.0
-    hs-source-dirs: tests
+  main-is:        Properties.hs
-    build-depends:  base,
+  other-modules:  Instances
-                    containers,
+                  Properties.Delete
-                    extensible-exceptions,
+                  Properties.Failure
-                    QuickCheck >= 2,
+                  Properties.Floating
-                    X11,
+                  Properties.Focus
-                    xmonad
+                  Properties.GreedyView
-    main-is: Properties.hs
+                  Properties.Insert
+                  Properties.Layout.Full
+                  Properties.Layout.Tall
+                  Properties.Screen
+                  Properties.Shift
+                  Properties.Stack
+                  Properties.StackSet
+                  Properties.Swap
+                  Properties.View
+                  Properties.Workspace
+                  Utils
+  hs-source-dirs: tests
+  build-depends:  base, QuickCheck >= 2, X11, containers, extensible-exceptions, xmonad