Bump version to 0.18.0

build(deps): bump actions/cache from 3 to 4
Bumps [actions/cache](https://github.com/actions/cache) from 3 to 4. - [Release notes](https://github.com/actions/cache/releases) - [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md) - [Commits](https://github.com/actions/cache/compare/v3...v4)
2025-07-25 17:21:52 -07:00 · 2024-02-03 16:01:11 +01:00 · 2024-01-22 11:54:43 +00:00 · 2024-01-17 12:08:06 +00:00 · 2024-01-17 11:52:56 +00:00 · 2024-01-17 11:52:56 +00:00
24 changed files with 439 additions and 195 deletions
--- a/.github/workflows/generatemanpage.yml
+++ b/.github/workflows/generatemanpage.yml
@@ -10,7 +10,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Clone project
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
@@ -26,8 +26,8 @@ jobs:
      - name: Commit/push if changed
        run: |
          set -ex
-          git config user.name github-actions
-          git config user.email github-actions@github.com
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
          git diff --quiet --exit-code && exit
          git commit -a -m 'man: Update'
          git push
--- a/.github/workflows/haskell-ci-hackage.patch
+++ b/.github/workflows/haskell-ci-hackage.patch
@@ -37,24 +37,26 @@ set in GitHub repository secrets.
 jobs:
   linux:
     name: Haskell-CI - Linux - ${{ matrix.compiler }}
-@@ -31,6 +38,7 @@
-             compilerVersion: 9.0.2
+@@ -33,6 +40,7 @@
+             compilerVersion: 9.8.1
             setup-method: ghcup
             allow-failure: false
 +            upload: true
-           - compiler: ghc-8.10.7
+           - compiler: ghc-9.6.4
             compilerKind: ghc
-             compilerVersion: 8.10.7
-@@ -237,7 +237,7 @@
-           ${CABAL} -vnormal check
+             compilerVersion: 9.6.4
+@@ -257,6 +265,10 @@
       - name: haddock
         run: |
-          $CABAL v2-haddock --disable-documentation $ARG_COMPILER --with-haddock $HADDOCK $ARG_TESTS $ARG_BENCH all
+           $CABAL v2-haddock --disable-documentation $ARG_COMPILER --with-haddock $HADDOCK $ARG_TESTS $ARG_BENCH all
+      - name: haddock for hackage
+        if: matrix.upload
+        run: |
 +          $CABAL v2-haddock $ARG_COMPILER --with-haddock $HADDOCK $ARG_TESTS $ARG_BENCH --haddock-for-hackage --builddir $GITHUB_WORKSPACE/haddock all
       - name: unconstrained build
         run: |
           rm -f cabal.project.local
-@@ -248,3 +248,75 @@
+@@ -267,3 +279,75 @@
         with:
           key: ${{ runner.os }}-${{ matrix.compiler }}-${{ github.sha }}
           path: ~/.cabal/store
--- a/.github/workflows/haskell-ci.yml
+++ b/.github/workflows/haskell-ci.yml
@@ -8,9 +8,9 @@
 #
 # For more information, see https://github.com/haskell-CI/haskell-ci
 #
-# version: 0.15.20230312
+# version: 0.17.20240109
 #
-# REGENDATA ("0.15.20230312",["github","cabal.project"])
+# REGENDATA ("0.17.20240109",["github","cabal.project"])
 #
 name: Haskell-CI
 on:
@@ -35,19 +35,25 @@ jobs:
    strategy:
      matrix:
        include:
-          - compiler: ghc-9.6.1
+          - compiler: ghc-9.8.1
            compilerKind: ghc
-            compilerVersion: 9.6.1
+            compilerVersion: 9.8.1
            setup-method: ghcup
            allow-failure: false
-          - compiler: ghc-9.4.4
+            upload: true
+          - compiler: ghc-9.6.4
            compilerKind: ghc
-            compilerVersion: 9.4.4
+            compilerVersion: 9.6.4
            setup-method: ghcup
            allow-failure: false
-          - compiler: ghc-9.2.7
+          - compiler: ghc-9.4.8
            compilerKind: ghc
-            compilerVersion: 9.2.7
+            compilerVersion: 9.4.8
+            setup-method: ghcup
+            allow-failure: false
+          - compiler: ghc-9.2.8
+            compilerKind: ghc
+            compilerVersion: 9.2.8
            setup-method: ghcup
            allow-failure: false
          - compiler: ghc-9.0.2
@@ -55,7 +61,6 @@ jobs:
            compilerVersion: 9.0.2
            setup-method: ghcup
            allow-failure: false
-            upload: true
          - compiler: ghc-8.10.7
            compilerKind: ghc
            compilerVersion: 8.10.7
@@ -79,10 +84,10 @@ jobs:
          apt-get install -y --no-install-recommends gnupg ca-certificates dirmngr curl git software-properties-common libtinfo5
          if [ "${{ matrix.setup-method }}" = ghcup ]; then
            mkdir -p "$HOME/.ghcup/bin"
-            curl -sL https://downloads.haskell.org/ghcup/0.1.18.0/x86_64-linux-ghcup-0.1.18.0 > "$HOME/.ghcup/bin/ghcup"
+            curl -sL https://downloads.haskell.org/ghcup/0.1.20.0/x86_64-linux-ghcup-0.1.20.0 > "$HOME/.ghcup/bin/ghcup"
            chmod a+x "$HOME/.ghcup/bin/ghcup"
            "$HOME/.ghcup/bin/ghcup" install ghc "$HCVER" || (cat "$HOME"/.ghcup/logs/*.* && false)
-            "$HOME/.ghcup/bin/ghcup" install cabal 3.10.1.0 || (cat "$HOME"/.ghcup/logs/*.* && false)
+            "$HOME/.ghcup/bin/ghcup" install cabal 3.10.2.0 || (cat "$HOME"/.ghcup/logs/*.* && false)
            apt-get update
            apt-get install -y libx11-dev libxext-dev libxinerama-dev libxrandr-dev libxss-dev
          else
@@ -90,9 +95,9 @@ jobs:
            apt-get update
            apt-get install -y "$HCNAME" libx11-dev libxext-dev libxinerama-dev libxrandr-dev libxss-dev
            mkdir -p "$HOME/.ghcup/bin"
-            curl -sL https://downloads.haskell.org/ghcup/0.1.18.0/x86_64-linux-ghcup-0.1.18.0 > "$HOME/.ghcup/bin/ghcup"
+            curl -sL https://downloads.haskell.org/ghcup/0.1.20.0/x86_64-linux-ghcup-0.1.20.0 > "$HOME/.ghcup/bin/ghcup"
            chmod a+x "$HOME/.ghcup/bin/ghcup"
-            "$HOME/.ghcup/bin/ghcup" install cabal 3.10.1.0 || (cat "$HOME"/.ghcup/logs/*.* && false)
+            "$HOME/.ghcup/bin/ghcup" install cabal 3.10.2.0 || (cat "$HOME"/.ghcup/logs/*.* && false)
          fi
        env:
          HCKIND: ${{ matrix.compilerKind }}
@@ -106,17 +111,19 @@ jobs:
          echo "CABAL_CONFIG=$HOME/.cabal/config" >> "$GITHUB_ENV"
          HCDIR=/opt/$HCKIND/$HCVER
          if [ "${{ matrix.setup-method }}" = ghcup ]; then
-            HC=$HOME/.ghcup/bin/$HCKIND-$HCVER
+            HC=$("$HOME/.ghcup/bin/ghcup" whereis ghc "$HCVER")
+            HCPKG=$(echo "$HC" | sed 's#ghc$#ghc-pkg#')
+            HADDOCK=$(echo "$HC" | sed 's#ghc$#haddock#')
            echo "HC=$HC" >> "$GITHUB_ENV"
-            echo "HCPKG=$HOME/.ghcup/bin/$HCKIND-pkg-$HCVER" >> "$GITHUB_ENV"
-            echo "HADDOCK=$HOME/.ghcup/bin/haddock-$HCVER" >> "$GITHUB_ENV"
-            echo "CABAL=$HOME/.ghcup/bin/cabal-3.10.1.0 -vnormal+nowrap" >> "$GITHUB_ENV"
+            echo "HCPKG=$HCPKG" >> "$GITHUB_ENV"
+            echo "HADDOCK=$HADDOCK" >> "$GITHUB_ENV"
+            echo "CABAL=$HOME/.ghcup/bin/cabal-3.10.2.0 -vnormal+nowrap" >> "$GITHUB_ENV"
          else
            HC=$HCDIR/bin/$HCKIND
            echo "HC=$HC" >> "$GITHUB_ENV"
            echo "HCPKG=$HCDIR/bin/$HCKIND-pkg" >> "$GITHUB_ENV"
            echo "HADDOCK=$HCDIR/bin/haddock" >> "$GITHUB_ENV"
-            echo "CABAL=$HOME/.ghcup/bin/cabal-3.10.1.0 -vnormal+nowrap" >> "$GITHUB_ENV"
+            echo "CABAL=$HOME/.ghcup/bin/cabal-3.10.2.0 -vnormal+nowrap" >> "$GITHUB_ENV"
          fi

          HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\d+)\.(\d+)\.(\d+)(\.(\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')
@@ -168,8 +175,8 @@ jobs:
      - name: install cabal-plan
        run: |
          mkdir -p $HOME/.cabal/bin
-          curl -sL https://github.com/haskell-hvr/cabal-plan/releases/download/v0.6.2.0/cabal-plan-0.6.2.0-x86_64-linux.xz > cabal-plan.xz
-          echo 'de73600b1836d3f55e32d80385acc055fd97f60eaa0ab68a755302685f5d81bc  cabal-plan.xz' | sha256sum -c -
+          curl -sL https://github.com/haskell-hvr/cabal-plan/releases/download/v0.7.3.0/cabal-plan-0.7.3.0-x86_64-linux.xz > cabal-plan.xz
+          echo 'f62ccb2971567a5f638f2005ad3173dba14693a45154c1508645c52289714cb2  cabal-plan.xz' | sha256sum -c -
          xz -d < cabal-plan.xz > $HOME/.cabal/bin/cabal-plan
          rm -f cabal-plan.xz
          chmod a+x $HOME/.cabal/bin/cabal-plan
@@ -238,6 +245,10 @@ jobs:
          cd ${PKGDIR_xmonad} || false
          ${CABAL} -vnormal check
      - name: haddock
+        run: |
+          $CABAL v2-haddock --disable-documentation $ARG_COMPILER --with-haddock $HADDOCK $ARG_TESTS $ARG_BENCH all
+      - name: haddock for hackage
+        if: matrix.upload
        run: |
          $CABAL v2-haddock $ARG_COMPILER --with-haddock $HADDOCK $ARG_TESTS $ARG_BENCH --haddock-for-hackage --builddir $GITHUB_WORKSPACE/haddock all
      - name: unconstrained build
--- a/.github/workflows/hlint.yaml
+++ b/.github/workflows/hlint.yaml
@@ -8,15 +8,15 @@ jobs:
  hlint:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4

    - name: 'Set up HLint'
-      uses: haskell/actions/hlint-setup@v2
+      uses: haskell-actions/hlint-setup@v2
      with:
        version: '3.5'

    - name: 'Run HLint'
-      uses: haskell/actions/hlint-run@v2
+      uses: haskell-actions/hlint-run@v2
      with:
        path: '.'
        fail-on: status
--- a/.github/workflows/nix.yml
+++ b/.github/workflows/nix.yml
@@ -12,7 +12,7 @@ jobs:
      contents: read
    steps:
      - name: Install Nix
-        uses: cachix/install-nix-action@v18
+        uses: cachix/install-nix-action@v25
        with:
          install_url: https://nixos-nix-install-tests.cachix.org/serve/i6laym9jw3wg9mw6ncyrk6gjx4l34vvx/install
          install_options: '--tarball-url-prefix https://nixos-nix-install-tests.cachix.org/serve'
@@ -20,6 +20,6 @@ jobs:
            experimental-features = nix-command flakes
            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
      - name: Clone project
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
      - name: Build
        run: nix build --print-build-logs
--- a/.github/workflows/packdeps.yml
+++ b/.github/workflows/packdeps.yml
@@ -13,16 +13,15 @@ jobs:

    steps:
      - name: Clone project
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
      - name: Setup Haskell
-        uses: haskell/actions/setup@v2
+        uses: haskell-actions/setup@v2
        with:
          # packdeps doesn't build with newer as of 2021-10
          ghc-version: '8.8'
      - name: Install packdeps
        run: |
          set -ex
-          echo "$HOME/.cabal/bin" >> $GITHUB_PATH
          cd  # go somewhere without a cabal.project
          cabal install packdeps
      - name: Check package bounds (all)
--- a/.github/workflows/stack.yml
+++ b/.github/workflows/stack.yml
@@ -17,10 +17,11 @@ jobs:
          - resolver: lts-18  # GHC 8.10
          - resolver: lts-19  # GHC 9.0
          - resolver: lts-20  # GHC 9.2
+          - resolver: lts-21  # GHC 9.4

    steps:
      - name: Clone project
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4

      - name: Install C dependencies
        run: |
@@ -44,13 +45,13 @@ jobs:
          date +date=1-%Y-%m >> $GITHUB_OUTPUT

      - name: Cache Haskell package metadata
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: ~/.stack/pantry
          key: stack-pantry-${{ runner.os }}-${{ steps.cache-date.outputs.date }}

      - name: Cache Haskell dependencies
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: |
            ~/.stack/*
--- a/.gitignore
+++ b/.gitignore
@@ -27,3 +27,6 @@ tags
 /cabal.sandbox.config
 /dist-newstyle/
 /dist/
+
+# nix artifacts
+result
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,35 @@
 # Change Log / Release Notes

+## 0.18.0 (February 3, 2024)
+
+### Breaking Changes
+
+* Dropped support for GHC 8.4.
+
+### Enhancements
+
+* Exported `sendRestart` and `sendReplace` from `XMonad.Operations`.
+
+* Exported `buildLaunch` from `XMonad.Main`.
+
+* `Tall` does not draw windows with zero area.
+
+* `XMonad.Operations.floatLocation` now applies size hints. This means windows
+  will snap to these hints as soon as they're floated (mouse move, keybinding).
+  Previously that only happened on mouse resize.
+
+* Recompilation now detects `flake.nix` and `default.nix` (can be a
+  symlink) and switches to using `nix build` as appropriate.
+
+* Added `unGrab` to `XMonad.Operations`; this releases XMonad's passive
+  keyboard grab, so other applications (like `scrot`) can do their
+  thing.
+
+### Bug Fixes
+
+* Duplicated floats (e.g. from X.A.CopyToAll) no longer escape to inactive
+  screens.
+
 ## 0.17.2 (April 2, 2023)

 ### Bug Fixes
@@ -14,6 +44,9 @@

  * Exported `cacheNumlockMask` and `mkGrabs` from `XMonad.Operations`.

+  * Added `willFloat` function to `XMonad.ManageHooks` to detect whether the
+    (about to be) managed window will be a floating window or not.
+
 ### Bug Fixes

  * Fixed border color of windows with alpha channel. Now all windows have the
@@ -71,9 +104,6 @@
  * Added `withUnfocused` function to `XMonad.Operations`, allowing for `X`
    operations to be applied to unfocused windows.

-  * Added `willFloat` function to `XMonad.ManageHooks` to detect whether the
-    (about to be) managed window will be a floating window or not
-
 [these build scripts]: https://github.com/xmonad/xmonad-testing/tree/master/build-scripts

 ### Bug Fixes
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -123,7 +123,9 @@ Unless you already know which one you prefer, use Stack, which is easier.

 #### Install Stack

-The easiest way to get [stack] is probably via your system's package
+Probably one of the best ways to get [stack] is to use [GHCup], which is the main Haskell installer according to language's official [website][GHCup] and community [survey]. GHCup is [widely available] and is considered less error prone than other installation options.
+
+You can also use your system's package
 manager:

 ``` console
@@ -145,9 +147,6 @@ stack via its [documentation][stack]):
 $ curl -sSL https://get.haskellstack.org/ | sh
 ```

-Yet another way would be via [ghcup]; this is similar to installers like
-`rustup`, in case you prefer that.
-
 #### Create a New Project

 Let's create a stack project.  Since we're already in the correct
@@ -222,7 +221,9 @@ be that you don't have the required C libraries installed.  See

 #### Install cabal-install

-The easiest way to get [cabal-install] is probably via your system's package
+Probably one of the best ways to get [cabal-install] is to use [GHCup], which is the main Haskell installer according to language's official [website][GHCup] and community [survey]. GHCup is [widely available] and is considered less error prone than other installation options.
+
+You can also use your system's package
 manager:

 ``` console
@@ -231,22 +232,22 @@ $ sudo dnf install cabal-install    # Fedora
 $ sudo pacman -S cabal-install      # Arch
 ```

-If your distribution does not package cabal-install, [ghcup][] is another
-option.  See also <https://www.haskell.org/cabal/#install-upgrade>.
+See also <https://www.haskell.org/cabal/#install-upgrade>.

 #### Create a New Project

-Let's create a cabal project.  Since we're already in the correct
-directory (`~/.config/xmonad`) with `xmonad` and `xmonad-contrib`
-subdirectories, we'll instruct cabal to use them.  Create a file named
-`cabal.project` containing:
+If you want to use `xmonad` or `xmonad-contrib` from git, you will need a
+`cabal.project` file. If you want to use both from [Hackage][], you should
+skip this step.
+
+Create a file named `cabal.project` containing:

 ```
 packages: */*.cabal
 ```

-(If you skip this step, cabal will use the latest releases from [Hackage][]
-instead.)
+(If you do this step without using [git] checkouts, you will get an error from
+cabal in the next step. Simply remove `cabal.project` and try again.)

 #### Install Everything

@@ -255,7 +256,7 @@ libraries and then build the xmonad binary:

 ``` console
 $ cabal update
-$ cabal install --package-env=$HOME/.config/xmonad --lib xmonad xmonad-contrib
+$ cabal install --package-env=$HOME/.config/xmonad --lib base xmonad xmonad-contrib
 $ cabal install --package-env=$HOME/.config/xmonad xmonad
 ```

@@ -393,7 +394,9 @@ executable will also be within that directory and not in
 [git]: https://git-scm.com/
 [stack]: https://docs.haskellstack.org/en/stable/README/
 [cabal-install]: https://www.haskell.org/cabal/
-[ghcup]: https://www.haskell.org/ghcup/
+[GHCup]: https://www.haskell.org/ghcup/
+[survey]: https://taylor.fausak.me/2022/11/18/haskell-survey-results/
+[widely available]: https://www.haskell.org/ghcup/install/#supported-platforms
 [what xmonad would do]: https://github.com/xmonad/xmonad/blob/master/src/XMonad/Core.hs#L659-L667
 [Hackage]: https://hackage.haskell.org/
 [scripts/build]: https://github.com/xmonad/xmonad-contrib/blob/master/scripts/build
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@@ -117,7 +117,12 @@ When the time comes to release another version of xmonad and xmonad-contrib:

     See [old announcements][old-announce] ([even older][older-announce]) for inspiration.

-  7. Bump version for development (add `.9`) and prepare fresh sections in
+  7. Trigger xmonad-docs build to generate and persist docs for the just
+     released version:
+
+     - https://github.com/xmonad/xmonad-docs/actions/workflows/stack.yml
+
+  8. Bump version for development (add `.9`) and prepare fresh sections in
     [`CHANGES.md`](CHANGES.md).

 [packdeps]: https://hackage.haskell.org/package/packdeps
--- a/README.md
+++ b/README.md
@@ -6,9 +6,9 @@
  <a href="https://github.com/xmonad/xmonad/blob/readme/LICENSE"><img alt="License" src="https://img.shields.io/github/license/xmonad/xmonad"></a>
  <a href="https://haskell.org/"><img alt="Made in Haskell" src="https://img.shields.io/badge/Made%20in-Haskell-%235e5086?logo=haskell"></a>
  <br>
-  <a href="https://github.com/xmonad/xmonad/actions/workflows/stack.yml"><img alt="Stack" src="https://img.shields.io/github/workflow/status/xmonad/xmonad/Stack?label=Stack&logo=githubactions&logoColor=white"></a>
-  <a href="https://github.com/xmonad/xmonad/actions/workflows/haskell-ci.yml"><img alt="Cabal" src="https://img.shields.io/github/workflow/status/xmonad/xmonad/Haskell-CI?label=Cabal&logo=githubactions&logoColor=white"></a>
-  <a href="https://github.com/xmonad/xmonad/actions/workflows/nix.yml"><img alt="Nix" src="https://img.shields.io/github/workflow/status/xmonad/xmonad/Nix?label=Nix&logo=githubactions&logoColor=white"></a>
+  <a href="https://github.com/xmonad/xmonad/actions/workflows/stack.yml"><img alt="Stack" src="https://img.shields.io/github/actions/workflow/status/xmonad/xmonad/stack.yml?label=Stack&logo=githubactions&logoColor=white"></a>
+  <a href="https://github.com/xmonad/xmonad/actions/workflows/haskell-ci.yml"><img alt="Cabal" src="https://img.shields.io/github/actions/workflow/status/xmonad/xmonad/haskell-ci.yml?label=Cabal&logo=githubactions&logoColor=white"></a>
+  <a href="https://github.com/xmonad/xmonad/actions/workflows/nix.yml"><img alt="Nix" src="https://img.shields.io/github/actions/workflow/status/xmonad/xmonad/nix.yml?label=Nix&logo=githubactions&logoColor=white"></a>
  <br>
  <a href="https://github.com/sponsors/xmonad"><img alt="GitHub Sponsors" src="https://img.shields.io/github/sponsors/xmonad?label=GitHub%20Sponsors&logo=githubsponsors"></a>
  <a href="https://opencollective.com/xmonad"><img alt="Open Collective" src="https://img.shields.io/opencollective/all/xmonad?label=Open%20Collective&logo=opencollective"></a>
--- a/TUTORIAL.md
+++ b/TUTORIAL.md
@@ -77,6 +77,11 @@ a live xmonad session in some capacity.  If you have set up your
 `~/.xinitrc` as directed in the xmonad guided tour, you should be good
 to go!  If not, just smack an `exec xmonad` at the bottom of that file.

+In particular, it might be a good idea to set a wallpaper beforehand.
+Otherwise, when switching workspaces or closing windows, you might start
+seeing "shadows" of windows that were there before, unable to interact
+with them.
+
 ## Installing Xmobar

 What we need to do now—provided we want to use a bar at all—is to
@@ -263,7 +268,7 @@ myLayout = tiled ||| Mirror tiled ||| Full
 ```

 The so-called `where`-clause above simply consists of local declarations
-that might clutter things up where they all declared at the top-level
+that might clutter things up were they all declared at the top-level
 like this

 ``` haskell
@@ -379,12 +384,16 @@ effect (and some applications, like chromium, will misbehave and need
 some [Hacks] to make this work), we will also add the relevant function
 to get "proper" fullscreen behaviour here.

+---
+
 _IF YOU ARE ON A VERSION `< 0.17.0`_: The `ewmhFullscreen` function does
  not exist in these versions.  Instead of it, you can try to add
  `fullscreenEventHook` to your `handleEventHook` to achieve similar
  functionality (how to do this is explained in the documentation of
  [XMonad.Hooks.EwmhDesktops]).

+---
+
 To use the two combinators, we compose them with the `xmonad` function
 in the following way:

@@ -430,7 +439,7 @@ Much better!
 ## Make XMonad and Xmobar Talk to Each Other

 Onto the main dish.  First, we have to import the necessary modules.
-Add the following to your list of imports:
+Add the following to your list of imports

 ``` haskell
 import XMonad.Hooks.DynamicLog
@@ -438,23 +447,27 @@ import XMonad.Hooks.StatusBar
 import XMonad.Hooks.StatusBar.PP
 ```

-_IF YOU ARE ON A VERSION `< 0.17.0`_: The `XMonad.Hooks.StatusBar` and
-  `XMonad.Hooks.StatusBar.PP` modules don't exist yet.  You can find
-  everything you need in the `XMonad.Hooks.DynamicLog` module, so remove
-  these two imports.
-
-Replace your `main` function above with:
+and replace your `main` function above with:

 ``` haskell
 main :: IO ()
 main = xmonad $ ewmhFullscreen $ ewmh $ xmobarProp $ myConfig
 ```

-_IF YOU ARE ON A VERSION `< 0.17.0`_: The `xmobarProp` function does not
-  exist in these versions.  Instead of it, use `xmobar` via
-  `main = xmonad . ewmh =<< xmobar myConfig` and carefully read the part
-  about pipes later on (`xmobar` uses pipes to make xmobar talk to
-  xmonad).
+---
+
+_IF YOU ARE ON A VERSION `< 0.17.0`_: The `XMonad.Hooks.StatusBar` and
+  `XMonad.Hooks.StatusBar.PP` modules don't exist yet.  You can find
+  everything you need in the `XMonad.Hooks.DynamicLog` module, so remove
+  these two imports.
+
+  Further, the `xmobarProp` function does not exist in older versions.
+  Instead of it, use `xmobar` via `main = xmonad . ewmh =<< xmobar
+  myConfig` and carefully read the part about pipes later on (`xmobar`
+  uses pipes to make xmobar talk to xmonad).  Do note the lack of
+  `ewmhFullscreen`, as explained above!
+
+---

 As a quick side-note, we could have also written

@@ -540,11 +553,15 @@ when things are not being read!  For this reason we have to use
 (this is useful, for example, for [XMonad.Util.ClickableWorkspaces],
 which is a new feature in `0.17.0`).

+---
+
 _IF YOU ARE ON A VERSION `< 0.17.0`_: As discussed above, the `xmobar`
  function uses pipes, so you actually do want to use the `StdinReader`.
  Simply replace _all_ occurences of `XMonadLog` with `StdinReader`
  below (don't forget the template!)

+---
+
 ## Configuring Xmobar

 Now, before this will work, we have to configure xmobar.  Here's a nice
@@ -660,6 +677,8 @@ main = xmonad
     $ myConfig
 ```

+---
+
 _IF YOU ARE ON A VERSION `< 0.17.0`_: `xmobar` has a similar definition,
  relying on `statusBar` alone: `xmobar = statusBar "xmobar" xmobarPP
    toggleStrutsKey`.  Sadly, the `defToggleStrutsKey` function is not yet
@@ -668,7 +687,6 @@ _IF YOU ARE ON A VERSION `< 0.17.0`_: `xmobar` has a similar definition,
 ``` haskell
 main :: IO ()
 main = xmonad
-     . ewmhFullscreen
     . ewmh
   =<< statusBar "xmobar" def toggleStrutsKey myConfig
  where
@@ -676,6 +694,8 @@ main = xmonad
    toggleStrutsKey XConfig{ modMask = m } = (m, xK_b)
 ```

+---
+
 The `defToggleStrutsKey` here is just the key with which you can toggle
 the bar; it is bound to `M-b`.  If you want to change this, you can also
 define your own:
@@ -772,6 +792,8 @@ myXmobarPP = def
    lowWhite = xmobarColor "#bbbbbb" ""
 ```

+---
+
 _IF YOU ARE ON A VERSION `< 0.17`_: Both `logTitles` and `xmobarBorder`
  are not available yet, so you will have to remove them.  As an
  alternative to `xmobarBorder`, a common way to "mark" the currently
@@ -779,6 +801,8 @@ _IF YOU ARE ON A VERSION `< 0.17`_: Both `logTitles` and `xmobarBorder`
  `ppCurrent = wrap (blue "[") (blue "]")` and see if you like it.  Also
  read the bit about `ppOrder` further down!

+---
+
 That's a lot!  But don't worry, take a deep breath and remind yourself
 of what you read above in the documentation of the [PP record].  Even if
 you haven't read the documentation yet, most of the fields should be
@@ -882,10 +906,10 @@ apt-get install nm-applet feh xfce4-power-manager

 First, configure xscreensaver how you like it with the
 `xscreensaver-demo` command.  Now, we will set these things up in
-`~/.xinitrc` (we could also do most of this in xmonad's `startupHook`,
-but `~/.xinitrc` is perhaps more standard).  If you want to use xmonad
-with a desktop environment, see [Basic Desktop Environment Integration]
-for how to do this.
+`~/.xinitrc`.  If you want to use XMonad with a desktop environment, see
+[Basic Desktop Environment Integration] for how to do this.  For a
+version using XMonad's built in functionality instead, see the [next
+section][using-the-startupHook].

 Your `~/.xinitrc` may wind up looking like this:

@@ -933,6 +957,38 @@ Mission accomplished!
 Of course substitute the wallpaper for one of your own.  If you like the
 one used above, you can find it [here](https://i.imgur.com/9MQHuZx.png).

+### Using the `startupHook`
+
+Instead of the `.xinitrc` file, one can also use XMonad's built in
+`startupHook` in order to auto start programs.  The
+[XMonad.Util.SpawnOnce] library is perfect for this use case, allowing
+programs to start only once, and not with every invocation of `M-q`!
+
+This requires but a small change in `myConfig`:
+
+``` haskell
+-- import XMonad.Util.SpawnOnce (spawnOnce)
+
+myConfig = def
+    { modMask     = mod4Mask       -- Rebind Mod to the Super key
+    , layoutHook  = myLayout       -- Use custom layouts
+    , startupHook = myStartupHook
+    }
+  `additionalKeysP`
+    [ ("M-S-z", spawn "xscreensaver-command -lock")
+    , ("M-C-s", unGrab *> spawn "scrot -s"        )
+    , ("M-f"  , spawn "firefox"                   )
+    ]
+
+myStartupHook :: X ()
+myStartupHook = do
+  spawnOnce "trayer --edge top --align right --SetDockType true \
+            \--SetPartialStrut true --expand true --width 10 \
+            \--transparent true --tint 0x5f5f5f --height 18"
+  spawnOnce "feh --bg-fill --no-fehbg ~/.wallpapers/haskell-red-noise.png"
+  -- … and so on …
+```
+
 ## Final Touches

 There may be some programs that you don't want xmonad to tile.  The
@@ -1238,21 +1294,22 @@ either :)
 [Basic Desktop Environment Integration]: https://wiki.haskell.org/Xmonad/Basic_Desktop_Environment_Integration

 [Hacks]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Util-Hacks.html
-[PP record]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Hooks-DynamicLog.html#t:PP
 [INSTALL.md]: INSTALL.md
+[PP record]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Hooks-DynamicLog.html#t:PP
 [XMonad.Config]: https://github.com/xmonad/xmonad/blob/master/src/XMonad/Config.hs
-[XMonad.ManageHook]: https://xmonad.github.io/xmonad-docs/xmonad/XMonad-ManageHook.html
-[XMonad.Util.Loggers]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Util-Loggers.html
-[XMonad.Util.EZConfig]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Util-EZConfig.html
-[XMonad.Layout.Renamed]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Layout-Renamed.html
-[XMonad.Layout.Magnifier]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Layout-Magnifier.html
 [XMonad.Doc.Contributing]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Doc-Configuring.html
 [XMonad.Hooks.EwmhDesktops]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Hooks-EwmhDesktops.html
-[XMonad.Layout.ThreeColumns]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Layout-ThreeColumns.html
 [XMonad.Hooks.ManageHelpers]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Hooks-ManageHelpers.html
+[XMonad.Layout.Magnifier]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Layout-Magnifier.html
+[XMonad.Layout.Renamed]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Layout-Renamed.html
+[XMonad.Layout.ThreeColumns]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Layout-ThreeColumns.html
+[XMonad.ManageHook]: https://xmonad.github.io/xmonad-docs/xmonad/XMonad-ManageHook.html
 [XMonad.Util.ClickableWorkspaces]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Util-ClickableWorkspaces.html
+[XMonad.Util.EZConfig]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Util-EZConfig.html
+[XMonad.Util.Loggers]: https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Util-Loggers.html
+[XMonad.Util.SpawnOnce]: https://hackage.haskell.org/package/xmonad-contrib/docs/XMonad-Util-SpawnOnce.html

-[xmobar]: https://xmobar.org/
+[xmobar]: https://codeberg.org/xmobar/xmobar
 [battery]: https://codeberg.org/xmobar/xmobar/src/branch/master/doc/plugins.org#batteryp-dirs-args-refreshrate
 [xmobar.hs]: https://codeberg.org/xmobar/xmobar/src/branch/master/etc/xmobar.hs
 [Wikipedia page]: https://en.wikipedia.org/wiki/ICAO_airport_code#Prefixes
--- a/flake.nix
+++ b/flake.nix
@@ -15,17 +15,26 @@
       else [ "haskell" "packages" compiler ]
      );
    fromHOL = hol: comp: final: prev: with prev.lib; with attrsets;
-      setAttrByPath (hpath comp)
-        ((getAttrFromPath (hpath comp) prev).override (old: {
+      let
+        path   = hpath comp;
+        root   = head path;
+        branch = tail path;
+        hpkgs' = (getAttrFromPath path prev).override (old: {
          overrides = composeExtensions (old.overrides or (_: _: {}))
            (hol final prev);
-        }));
+        });
+      in {
+        ${root} = recursiveUpdate prev.${root} (setAttrByPath branch hpkgs');
+      };
    hoverlay = final: prev: hself: hsuper:
      with prev.haskell.lib.compose; {
        xmonad = hself.callCabal2nix "xmonad"
          (git-ignore-nix.lib.gitignoreSource ./.) { };
      };
-    overlay = fromHOL hoverlay { };
+    defComp = if builtins.pathExists ./comp.nix
+      then import ./comp.nix
+      else { };
+    overlay = fromHOL hoverlay defComp;
    overlays = [ overlay ];
    nixosModule = { config, pkgs, lib, ... }: with lib; with attrsets;
      let
@@ -64,12 +73,32 @@
    nixosModules = [ nixosModule ];
  in flake-utils.lib.eachDefaultSystem (system:
  let pkgs = import nixpkgs { inherit system overlays; };
+      hpkg = pkgs.lib.attrsets.getAttrFromPath (hpath defComp) pkgs;
+      modifyDevShell =
+        if builtins.pathExists ./develop.nix
+        then import ./develop.nix
+        else _: x: x;
  in
  rec {
-    devShell = pkgs.haskellPackages.shellFor {
+    devShell = hpkg.shellFor (modifyDevShell pkgs {
      packages = p: [ p.xmonad ];
-    };
-    defaultPackage = pkgs.haskellPackages.xmonad;
+    });
+    defaultPackage = hpkg.xmonad;
+    # An auxiliary NixOS module that modernises the standard xmonad NixOS module
+    # and wrapper script used, replacing them with versions from unstable.
+    # Currently, due to the NIX_GHC --> XMONAD_GHC env var change, this is
+    # necessary in order for Mod-q recompilation to work out-of-the-box.
+    modernise =
+      let
+        xmonadModFile = "services/x11/window-managers/xmonad.nix";
+        unpkgs = import unstable { inherit system; };
+        replaceWrapper = _: _:
+          { xmonad-with-packages = unpkgs.xmonad-with-packages; };
+      in {
+        disabledModules = [ xmonadModFile ];
+        imports = [ (unstable + "/nixos/modules/" + xmonadModFile) ];
+        nixpkgs.overlays = [ replaceWrapper ];
+      };
  }) // {
    inherit hoverlay overlay overlays nixosModule nixosModules;
    lib = { inherit hpath fromHOL; };
--- a/src/XMonad/Core.hs
+++ b/src/XMonad/Core.hs
@@ -7,6 +7,7 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE DerivingVia #-}

 -----------------------------------------------------------------------------
 -- |
@@ -32,7 +33,7 @@ module XMonad.Core (
    StateExtension(..), ExtensionClass(..), ConfExtension(..),
    runX, catchX, userCode, userCodeDef, io, catchIO, installSignalHandlers, uninstallSignalHandlers,
    withDisplay, withWindowSet, isRoot, runOnWorkspaces,
-    getAtom, spawn, spawnPID, xfork, xmessage, recompile, trace, whenJust, whenX,
+    getAtom, spawn, spawnPID, xfork, xmessage, recompile, trace, whenJust, whenX, ifM,
    getXMonadDir, getXMonadCacheDir, getXMonadDataDir, stateFileName, binFileName,
    atom_WM_STATE, atom_WM_PROTOCOLS, atom_WM_DELETE_WINDOW, atom_WM_TAKE_FOCUS, withWindowAttributes,
    ManageHook, Query(..), runQuery, Directories'(..), Directories, getDirectories,
@@ -48,12 +49,13 @@ import Control.Monad.Fail
 import Control.Monad.Fix (fix)
 import Control.Monad.State
 import Control.Monad.Reader
-import Control.Monad (filterM, guard, liftM2, void, when)
+import Control.Monad (filterM, guard, void, when)
 import Data.Semigroup
 import Data.Traversable (for)
 import Data.Time.Clock (UTCTime)
 import Data.Default.Class
 import System.Environment (lookupEnv)
+import Data.List (isInfixOf, intercalate, (\\))
 import System.FilePath
 import System.IO
 import System.Info
@@ -68,8 +70,8 @@ import System.Exit
 import Graphics.X11.Xlib
 import Graphics.X11.Xlib.Extras (getWindowAttributes, WindowAttributes, Event)
 import Data.Typeable
-import Data.List (isInfixOf, (\\))
 import Data.Maybe (isJust,fromMaybe)
+import Data.Monoid (Ap(..))

 import qualified Data.Map as M
 import qualified Data.Set as S
@@ -165,12 +167,7 @@ newtype ScreenDetail = SD { screenRect :: Rectangle }
 --
 newtype X a = X (ReaderT XConf (StateT XState IO) a)
    deriving (Functor, Applicative, Monad, MonadFail, MonadIO, MonadState XState, MonadReader XConf)
-
-instance Semigroup a => Semigroup (X a) where
-    (<>) = liftM2 (<>)
-
-instance (Monoid a) => Monoid (X a) where
-    mempty = pure mempty
+    deriving (Semigroup, Monoid) via Ap X a

 instance Default a => Default (X a) where
    def = return def
@@ -178,16 +175,11 @@ instance Default a => Default (X a) where
 type ManageHook = Query (Endo WindowSet)
 newtype Query a = Query (ReaderT Window X a)
    deriving (Functor, Applicative, Monad, MonadReader Window, MonadIO)
+    deriving (Semigroup, Monoid) via Ap Query a

 runQuery :: Query a -> Window -> X a
 runQuery (Query m) = runReaderT m

-instance Semigroup a => Semigroup (Query a) where
-    (<>) = liftM2 (<>)
-
-instance Monoid a => Monoid (Query a) where
-    mempty = pure mempty
-
 instance Default a => Default (Query a) where
    def = return def

@@ -423,9 +415,13 @@ data StateExtension =
 data ConfExtension = forall a. Typeable a => ConfExtension a

 -- ---------------------------------------------------------------------
-- | General utilities
--
-- Lift an 'IO' action into the 'X' monad
+-- General utilities
+
+-- | If-then-else lifted to a 'Monad'.
+ifM :: Monad m => m Bool -> m a -> m a -> m a
+ifM mb t f = mb >>= \b -> if b then t else f
+
+-- | Lift an 'IO' action into the 'X' monad
 io :: MonadIO m => IO a -> m a
 io = liftIO

@@ -584,21 +580,31 @@ srcFileName, libFileName :: Directories -> FilePath
 srcFileName Directories{ cfgDir } = cfgDir </> "xmonad.hs"
 libFileName Directories{ cfgDir } = cfgDir </> "lib"

-buildScriptFileName, stackYamlFileName :: Directories -> FilePath
+buildScriptFileName, stackYamlFileName, nixFlakeFileName, nixDefaultFileName :: Directories -> FilePath
 buildScriptFileName Directories{ cfgDir } = cfgDir </> "build"
 stackYamlFileName   Directories{ cfgDir } = cfgDir </> "stack.yaml"
+nixFlakeFileName    Directories{ cfgDir } = cfgDir </> "flake.nix"
+nixDefaultFileName  Directories{ cfgDir } = cfgDir </> "default.nix"

 -- | Compilation method for xmonad configuration.
-data Compile = CompileGhc | CompileStackGhc FilePath | CompileScript FilePath
+data Compile
+  = CompileGhc
+  | CompileStackGhc FilePath
+  | CompileNixFlake
+  | CompileNixDefault
+  | CompileScript FilePath
    deriving (Show)

 -- | Detect compilation method by looking for known file names in xmonad
 -- configuration directory.
 detectCompile :: Directories -> IO Compile
-detectCompile dirs = tryScript <|> tryStack <|> useGhc
+detectCompile dirs =
+  tryScript <|> tryStack <|> tryNixFlake <|> tryNixDefault <|> useGhc
  where
    buildScript = buildScriptFileName dirs
    stackYaml = stackYamlFileName dirs
+    flakeNix = nixFlakeFileName dirs
+    defaultNix = nixDefaultFileName dirs

    tryScript = do
        guard =<< doesFileExist buildScript
@@ -612,6 +618,18 @@ detectCompile dirs = tryScript <|> tryStack <|> useGhc
            trace $ "Suggested resolution to use it: chmod u+x " <> show buildScript
            empty

+    tryNixFlake = do
+      guard =<< doesFileExist flakeNix
+      canonNixFlake <- canonicalizePath flakeNix
+      trace $ "XMonad will use nix flake at " <> show canonNixFlake <> " to recompile"
+      pure CompileNixFlake
+
+    tryNixDefault = do
+      guard =<< doesFileExist defaultNix
+      canonNixDefault <- canonicalizePath defaultNix
+      trace $ "XMonad will use nix file at " <> show canonNixDefault <> " to recompile"
+      pure CompileNixDefault
+
    tryStack = do
        guard =<< doesFileExist stackYaml
        canonStackYaml <- canonicalizePath stackYaml
@@ -619,11 +637,18 @@ detectCompile dirs = tryScript <|> tryStack <|> useGhc
        pure $ CompileStackGhc canonStackYaml

    useGhc = do
-        trace $ "XMonad will use ghc to recompile, because neither "
-                <> show buildScript <> " nor " <> show stackYaml <> " exists."
+        trace $ "XMonad will use ghc to recompile, because none of "
+                <> intercalate ", "
+                     [ show buildScript
+                     , show stackYaml
+                     , show flakeNix
+                     , show defaultNix
+                     ] <> " exist."
        pure CompileGhc

-    isExecutable f = E.catch (executable <$> getPermissions f) (\(SomeException _) -> return False)
+-- | Determine whether or not the file found at the provided filepath is executable.
+isExecutable :: FilePath -> IO Bool
+isExecutable f = E.catch (executable <$> getPermissions f) (\(SomeException _) -> return False)

 -- | Should we recompile xmonad configuration? Is it newer than the compiled
 -- binary?
@@ -648,6 +673,8 @@ shouldCompile dirs CompileStackGhc{} = do
    if binT < stackYamlT
        then True <$ trace "XMonad recompiling because some files have changed."
        else shouldCompile dirs CompileGhc
+shouldCompile _dirs CompileNixFlake{} = True <$ trace "XMonad recompiling because flake recompilation is being used."
+shouldCompile _dirs CompileNixDefault{} = True <$ trace "XMonad recompiling because nix recompilation is being used."
 shouldCompile _dirs CompileScript{} =
    True <$ trace "XMonad recompiling because a custom build script is being used."

@@ -667,6 +694,10 @@ compile dirs method =
                CompileStackGhc stackYaml ->
                    run "stack" ["build", "--silent", "--stack-yaml", stackYaml] .&&.
                    run "stack" ("ghc" : "--stack-yaml" : stackYaml : "--" : ghcArgs)
+                CompileNixFlake ->
+                    run "nix" ["build"] >>= andCopyFromResultDir
+                CompileNixDefault ->
+                    run "nix-build" [] >>= andCopyFromResultDir
                CompileScript script ->
                    run script [binFileName dirs]
  where
@@ -680,6 +711,18 @@ compile dirs method =
              , "-outputdir", buildDirName dirs
              , "-o", binFileName dirs
              ]
+    andCopyFromResultDir exitCode = do
+      if exitCode == ExitSuccess then copyFromResultDir else return exitCode
+    findM p = foldr (\x -> ifM (p x) (pure $ Just x)) (pure Nothing)
+    catchAny :: IO a -> (SomeException -> IO a) -> IO a
+    catchAny = E.catch
+    copyFromResultDir = do
+      let binaryDirectory = cfgDir dirs </> "result" </> "bin"
+      binFiles <- map (binaryDirectory </>) <$> catchAny (listDirectory binaryDirectory) (\_ -> return [])
+      mfilepath <- findM isExecutable binFiles
+      case mfilepath of
+        Just filepath -> copyFile filepath (binFileName dirs) >> return ExitSuccess
+        Nothing -> return $ ExitFailure 1

    -- waitForProcess =<< System.Process.runProcess, but without closing the err handle
    runProc cwd err exe args = do
--- a/src/XMonad/Layout.hs
+++ b/src/XMonad/Layout.hs
@@ -62,9 +62,13 @@ data Tall a = Tall { tallNMaster :: !Int               -- ^ The default number o

 -- a nice pure layout, lots of properties for the layout, and its messages, in Properties.hs
 instance LayoutClass Tall a where
-    pureLayout (Tall nmaster _ frac) r s = zip ws rs
+    pureLayout (Tall nmaster _ frac) r s
+        | frac == 0 = drop nmaster layout
+        | frac == 1 = take nmaster layout
+        | otherwise = layout
      where ws = W.integrate s
            rs = tile frac r nmaster (length ws)
+            layout = zip ws rs

    pureMessage (Tall nmaster delta frac) m =
            msum [fmap resize     (fromMessage m)
--- a/src/XMonad/Main.hs
+++ b/src/XMonad/Main.hs
@@ -15,14 +15,13 @@
 --
 -----------------------------------------------------------------------------

-module XMonad.Main (xmonad, launch) where
+module XMonad.Main (xmonad, buildLaunch, launch) where

 import System.Locale.SetLocale
 import qualified Control.Exception as E
 import Data.Bits
 import Data.List ((\\))
 import Data.Foldable (traverse_)
-import Data.Function
 import qualified Data.Map as M
 import qualified Data.Set as S
 import Control.Monad.Reader
@@ -132,25 +131,6 @@ buildLaunch dirs = do
      args <- getArgs
      executeFile bin False args Nothing

-sendRestart :: IO ()
-sendRestart = do
-    dpy <- openDisplay ""
-    rw <- rootWindow dpy $ defaultScreen dpy
-    xmonad_restart <- internAtom dpy "XMONAD_RESTART" False
-    allocaXEvent $ \e -> do
-        setEventType e clientMessage
-        setClientMessageEvent' e rw xmonad_restart 32 []
-        sendEvent dpy rw False structureNotifyMask e
-    sync dpy False
-
-- | a wrapper for 'replace'
-sendReplace :: IO ()
-sendReplace = do
-    dpy <- openDisplay ""
-    let dflt = defaultScreen dpy
-    rootw  <- rootWindow dpy dflt
-    replace dpy dflt rootw
-
 -- | Entry point into xmonad for custom builds.
 --
 -- This function isn't meant to be called by the typical xmonad user
@@ -485,36 +465,3 @@ grabButtons = do
    ems <- extraModifiers
    ba <- asks buttonActions
    mapM_ (\(m,b) -> mapM_ (grab b . (m .|.)) ems) (M.keys ba)
-
-- | @replace@ to signals compliant window managers to exit.
-replace :: Display -> ScreenNumber -> Window -> IO ()
-replace dpy dflt rootw = do
-    -- check for other WM
-    wmSnAtom <- internAtom dpy ("WM_S" ++ show dflt) False
-    currentWmSnOwner <- xGetSelectionOwner dpy wmSnAtom
-    when (currentWmSnOwner /= 0) $ do
-        -- prepare to receive destroyNotify for old WM
-        selectInput dpy currentWmSnOwner structureNotifyMask
-
-        -- create off-screen window
-        netWmSnOwner <- allocaSetWindowAttributes $ \attributes -> do
-            set_override_redirect attributes True
-            set_event_mask attributes propertyChangeMask
-            let screen = defaultScreenOfDisplay dpy
-                visual = defaultVisualOfScreen screen
-                attrmask = cWOverrideRedirect .|. cWEventMask
-            createWindow dpy rootw (-100) (-100) 1 1 0 copyFromParent copyFromParent visual attrmask attributes
-
-        -- try to acquire wmSnAtom, this should signal the old WM to terminate
-        xSetSelectionOwner dpy wmSnAtom netWmSnOwner currentTime
-
-        -- SKIPPED: check if we acquired the selection
-        -- SKIPPED: send client message indicating that we are now the WM
-
-        -- wait for old WM to go away
-        fix $ \again -> do
-            evt <- allocaXEvent $ \event -> do
-                windowEvent dpy currentWmSnOwner structureNotifyMask event
-                get_EventType event
-
-            when (evt /= destroyNotify) again
--- a/src/XMonad/ManageHook.hs
+++ b/src/XMonad/ManageHook.hs
@@ -64,10 +64,6 @@ x <&&> y = ifM x y (pure False)
 (<||>) :: Monad m => m Bool -> m Bool -> m Bool
 x <||> y = ifM x (pure True) y

-- | If-then-else lifted to a 'Monad'.
-ifM :: Monad m => m Bool -> m a -> m a -> m a
-ifM mb t f = mb >>= \b -> if b then t else f
-
 -- | Return the window title.
 title :: Query String
 title = ask >>= \w -> liftX $ do
@@ -77,7 +73,7 @@ title = ask >>= \w -> liftX $ do
            (internAtom d "_NET_WM_NAME" False >>= getTextProperty d w)
                `E.catch` \(SomeException _) -> getTextProperty d w wM_NAME
        extract prop = do l <- wcTextPropertyToTextList d prop
-                          return $ if null l then "" else head l
+                          return $ fromMaybe "" $ listToMaybe l
    io $ bracket getProp (xFree . tp_value) extract `E.catch` \(SomeException _) -> return ""

 -- | Return the application name; i.e., the /first/ string returned by
--- a/src/XMonad/Operations.hs
+++ b/src/XMonad/Operations.hs
@@ -33,10 +33,11 @@ module XMonad.Operations (
    -- * Keyboard and Mouse
    cleanMask, extraModifiers,
    mouseDrag, mouseMoveWindow, mouseResizeWindow,
-    setButtonGrab, setFocusX, cacheNumlockMask, mkGrabs,
+    setButtonGrab, setFocusX, cacheNumlockMask, mkGrabs, unGrab,

    -- * Messages
    sendMessage, broadcastMessage, sendMessageWithNoRefresh,
+    sendRestart, sendReplace,

    -- * Save and Restore State
    StateFile (..), writeStateToFile, readStateFile, restart,
@@ -196,6 +197,7 @@ windows f = do
        let m   = W.floating ws
            flt = [(fw, scaleRationalRect viewrect r)
                    | fw <- filter (`M.member` m) (W.index this)
+                    , fw `notElem` vis
                    , Just r <- [M.lookup fw m]]
            vs = flt ++ rs

@@ -473,6 +475,28 @@ mkGrabs ks = withDisplay $ \dpy -> do
         , extraMod    <- extraMods
         ]

+-- | Release XMonad's keyboard grab, so other grabbers can do their thing.
+--
+-- Start a keyboard action with this if it is going to run something
+-- that needs to do a keyboard, pointer, or server grab. For example,
+--
+-- > , ((modm .|. controlMask, xK_p), unGrab >> spawn "scrot")
+--
+-- (Other examples are certain screen lockers and "gksu".)
+-- This avoids needing to insert a pause/sleep before running the
+-- command.
+--
+-- XMonad retains the keyboard grab during key actions because if they
+-- use a submap, they need the keyboard to be grabbed, and if they had
+-- to assert their own grab then the asynchronous nature of X11 allows
+-- race conditions between XMonad, other clients, and the X server that
+-- would cause keys to sometimes be "leaked" to the focused window.
+unGrab :: X ()
+unGrab = withDisplay $ \d -> io $ do
+    ungrabKeyboard d currentTime
+    ungrabPointer  d currentTime
+    sync d False
+
 ------------------------------------------------------------------------
 -- Message handling

@@ -519,6 +543,59 @@ setLayout l = do
    handleMessage (W.layout ws) (SomeMessage ReleaseResources)
    windows $ const $ ss{ W.current = c{ W.workspace = ws{ W.layout = l } } }

+-- | Signal xmonad to restart itself.
+sendRestart :: IO ()
+sendRestart = do
+    dpy <- openDisplay ""
+    rw  <- rootWindow dpy $ defaultScreen dpy
+    xmonad_restart <- internAtom dpy "XMONAD_RESTART" False
+    allocaXEvent $ \e -> do
+        setEventType e clientMessage
+        setClientMessageEvent' e rw xmonad_restart 32 []
+        sendEvent dpy rw False structureNotifyMask e
+    sync dpy False
+
+-- | Signal compliant window managers to exit.
+sendReplace :: IO ()
+sendReplace = do
+    dpy <- openDisplay ""
+    let dflt = defaultScreen dpy
+    rootw <- rootWindow dpy dflt
+    replace dpy dflt rootw
+
+-- | Signal compliant window managers to exit.
+replace :: Display -> ScreenNumber -> Window -> IO ()
+replace dpy dflt rootw = do
+    -- check for other WM
+    wmSnAtom <- internAtom dpy ("WM_S" ++ show dflt) False
+    currentWmSnOwner <- xGetSelectionOwner dpy wmSnAtom
+    when (currentWmSnOwner /= 0) $ do
+        -- prepare to receive destroyNotify for old WM
+        selectInput dpy currentWmSnOwner structureNotifyMask
+
+        -- create off-screen window
+        netWmSnOwner <- allocaSetWindowAttributes $ \attributes -> do
+            set_override_redirect attributes True
+            set_event_mask attributes propertyChangeMask
+            let screen = defaultScreenOfDisplay dpy
+                visual = defaultVisualOfScreen screen
+                attrmask = cWOverrideRedirect .|. cWEventMask
+            createWindow dpy rootw (-100) (-100) 1 1 0 copyFromParent copyFromParent visual attrmask attributes
+
+        -- try to acquire wmSnAtom, this should signal the old WM to terminate
+        xSetSelectionOwner dpy wmSnAtom netWmSnOwner currentTime
+
+        -- SKIPPED: check if we acquired the selection
+        -- SKIPPED: send client message indicating that we are now the WM
+
+        -- wait for old WM to go away
+        fix $ \again -> do
+            evt <- allocaXEvent $ \event -> do
+                windowEvent dpy currentWmSnOwner structureNotifyMask event
+                get_EventType event
+
+            when (evt /= destroyNotify) again
+
 ------------------------------------------------------------------------
 -- Utilities

@@ -649,6 +726,7 @@ floatLocation w =

  where go = withDisplay $ \d -> do
          ws <- gets windowset
+          sh <- io $ getWMNormalHints d w
          wa <- io $ getWindowAttributes d w
          let bw = (fromIntegral . wa_border_width) wa
          point_sc <- pointScreen (fi $ wa_x wa) (fi $ wa_y wa)
@@ -663,13 +741,14 @@ floatLocation w =
              sr = screenRect . W.screenDetail $ sc
              x = (fi (wa_x wa) - fi (rect_x sr)) % fi (rect_width sr)
              y = (fi (wa_y wa) - fi (rect_y sr)) % fi (rect_height sr)
-              width  = fi (wa_width  wa + bw*2) % fi (rect_width sr)
-              height = fi (wa_height wa + bw*2) % fi (rect_height sr)
+              (width, height) = applySizeHintsContents sh (wa_width wa, wa_height wa)
+              rwidth  = fi (width + bw*2) % fi (rect_width sr)
+              rheight = fi (height + bw*2) % fi (rect_height sr)
              -- adjust x/y of unmanaged windows if we ignored or didn't get pointScreen,
              -- it might be out of bounds otherwise
              rr = if managed || point_sc `sr_eq` Just sc
-                  then W.RationalRect x y width height
-                  else W.RationalRect (0.5 - width/2) (0.5 - height/2) width height
+                  then W.RationalRect x y rwidth rheight
+                  else W.RationalRect (0.5 - rwidth/2) (0.5 - rheight/2) rwidth rheight

          return (W.screen sc, rr)

--- a/src/XMonad/StackSet.hs
+++ b/src/XMonad/StackSet.hs
@@ -106,7 +106,10 @@ import qualified Data.Map  as M (Map,insert,delete,empty)
 --
 --      <https://dspace.library.uu.nl/handle/1874/2532 R. Hinze and J. Jeuring, Functional Pearl: Weaving a Web>
 --
-- and Conor McBride's zipper differentiation paper.
+-- and
+--
+--      <http://strictlypositive.org/diff.pdf Conor McBride, The Derivative of a Regular Type is its Type of One-Hole Contexts>.
+--
 -- Another good reference is: <https://wiki.haskell.org/Zipper The Zipper, Haskell wikibook>

 -- $xinerama
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,4 +1,4 @@
-resolver: lts-19.6
+resolver: lts-21.12

 packages:
 - ./
--- a/tests/Properties.hs
+++ b/tests/Properties.hs
@@ -166,11 +166,16 @@ tests =
  -- tall layout

  ,("tile 1 window fullsize", property prop_tile_fullscreen)
+  ,("tile max ratio",         property prop_tile_max_ratio)
+  ,("tile min ratio",         property prop_tile_min_ratio)
  ,("tiles never overlap",    property prop_tile_non_overlap)
  ,("split horizontal",       property prop_split_horizontal)
  ,("split vertical",         property prop_split_vertical)

-  ,("pure layout tall",       property prop_purelayout_tall)
+  ,("pure layout tall",            property prop_purelayout_tall)
+    {- Following two test cases should be automatically generated by QuickCheck ideally, but it fails. -}
+  ,("pure layout tall: ratio = 0", property (\n d rect -> prop_purelayout_tall n d 0 rect))
+  ,("pure layout tall: ratio = 1", property (\n d rect -> prop_purelayout_tall n d 1 rect))
  ,("send shrink    tall",    property prop_shrink_tall)
  ,("send expand    tall",    property prop_expand_tall)
  ,("send incmaster tall",    property prop_incmaster_tall)
--- a/tests/Properties/Layout/Tall.hs
+++ b/tests/Properties/Layout/Tall.hs
@@ -11,8 +11,9 @@ import XMonad.Layout

 import Graphics.X11.Xlib.Types (Rectangle(..))

-import Data.Maybe
+import Control.Applicative
 import Data.List (sort)
+import Data.Maybe
 import Data.Ratio

 ------------------------------------------------------------------------
@@ -27,6 +28,22 @@ prop_tile_non_overlap rect windows nmaster = noOverlaps (tile pct rect nmaster w
  where _ = rect :: Rectangle
        pct = 3 % 100

+-- with a ratio of 1, no stack windows are drawn of there is at least
+-- one master window around.
+prop_tile_max_ratio = extremeRatio 1 drop
+
+-- with a ratio of 0, no master windows are drawn at all if there are
+-- any stack windows around.
+prop_tile_min_ratio = extremeRatio 0 take
+
+extremeRatio amount getRects rect = do
+    w@(NonNegative windows) <- arbitrary `suchThat` (> NonNegative 0)
+    NonNegative nmaster     <- arbitrary `suchThat` (< w)
+    let tiled = tile amount rect nmaster windows
+    pure $ if   nmaster == 0
+           then prop_tile_non_overlap rect windows nmaster
+           else all ((== 0) . rect_width) $ getRects nmaster tiled
+
 -- splitting horizontally yields sensible results
 prop_split_horizontal (NonNegative n) x =
      noOverflows (+) (rect_x x) (rect_width x) ==>
@@ -49,13 +66,20 @@ prop_split_vertical (r :: Rational) x =


 -- pureLayout works.
-prop_purelayout_tall n r1 r2 rect = do
+prop_purelayout_tall n d r rect = do
  x <- (arbitrary :: Gen T) `suchThat` (isJust . peek)
-  let layout = Tall n r1 r2
+  let layout = Tall n d r
      st = fromJust . stack . workspace . current $ x
      ts = pureLayout layout rect st
+      ntotal = length (index x)
  return $
-        length ts == length (index x)
+       (if r == 0 then
+          -- (<=) for Bool is the logical implication
+          (0 <= n && n <= ntotal) <= (length ts == ntotal - n)
+        else if r == 1 then
+          (0 <= n && n <= ntotal) <= (length ts == n)
+        else
+          length ts == ntotal)
      &&
        noOverlaps (map snd ts)
      &&
--- a/xmonad.cabal
+++ b/xmonad.cabal
@@ -1,5 +1,5 @@
 name:               xmonad
-version:            0.17.2
+version:            0.18.0
 synopsis:           A tiling window manager
 description:        xmonad is a tiling window manager for X. Windows are arranged
                    automatically to tile the screen without gaps or overlap, maximising
@@ -27,7 +27,7 @@ author:             Spencer Janssen, Don Stewart, Adam Vogt, David Roundy, Jason
                    Ondřej Súkup, Paul Hebble, Shachaf Ben-Kiki, Siim Põder, Tim McIver,
                    Trevor Elliott, Wouter Swierstra, Conrad Irwin, Tim Thelion, Tony Zorman
 maintainer:         xmonad@haskell.org
-tested-with:        GHC == 8.6.5 || == 8.8.4 || == 8.10.7 || == 9.0.2 || == 9.2.7 || == 9.4.4 || == 9.6.1
+tested-with:        GHC == 8.6.5 || == 8.8.4 || == 8.10.7 || == 9.0.2 || == 9.2.8 || == 9.4.8 || == 9.6.4 || == 9.8.1
 category:           System
 homepage:           http://xmonad.org
 bug-reports:        https://github.com/xmonad/xmonad/issues
@@ -129,5 +129,8 @@ test-suite properties
                , xmonad
  default-language: Haskell2010

+  if impl(ghc > 9.8)
+    ghc-options:   -Wno-x-partial
+
  if flag(pedantic)
    ghc-options:   -Werror