Format with ormolu.

35 files changed, 1740 insertions, 1613 deletions

diff --git a/src/Rahm/Desktop/Common.hs b/src/Rahm/Desktop/Common.hs
index 3e6d54c..e012a8f 100644
--- a/src/Rahm/Desktop/Common.hs
+++ b/src/Rahm/Desktop/Common.hs
@@ -1,59 +1,61 @@
 module Rahm.Desktop.Common where
 
-import Prelude hiding ((!!))
-
-import Control.Monad (void, when, forM_)
+import Control.Monad (forM_, void, when)
 import Control.Monad.Trans.Maybe
-import XMonad.Util.Run
-import XMonad.Prompt
-import XMonad.Prompt.Input
-import XMonad.Prompt.Shell
-import XMonad.Util.XUtils
-
-import Rahm.Desktop.PromptConfig
-
 import Data.Char
 import Data.List hiding ((!!))
 import Data.List.Safe ((!!))
-import Data.Maybe
-import Text.Printf
-import XMonad hiding (workspaces, Screen)
 import qualified Data.Map as Map
-import Rahm.Desktop.DMenu
+import Data.Maybe
 import Data.Ord (comparing)
-
+import Rahm.Desktop.DMenu
+import Rahm.Desktop.PromptConfig
 import qualified Rahm.Desktop.StackSet as S
+import Text.Printf
+import XMonad hiding (Screen, workspaces)
+import XMonad.Prompt
+import XMonad.Prompt.Input
+import XMonad.Prompt.Shell
+import XMonad.Util.Run
+import XMonad.Util.XUtils
+import Prelude hiding ((!!))
 
 -- A location is a workspace and maybe a window with that workspace.
-data Location = Location {
-    locationWorkspace :: WorkspaceId,
+data Location = Location
+  { locationWorkspace :: WorkspaceId,
     locationWindow :: Maybe Window
-  } deriving (Read, Show, Eq, Ord)
+  }
+  deriving (Read, Show, Eq, Ord)
 
 focusLocation :: Location -> X ()
 focusLocation (Location ws Nothing) = windows $ S.greedyView ws
 focusLocation (Location _ (Just win)) = windows $ S.focusWindow win
 
 masterWindow :: MaybeT X Window
-masterWindow = MaybeT $ withWindowSet $ \ss ->
-  let windows = (S.integrate' . S.stack . S.workspace . S.current) ss
-    in case windows of
-      (a:_) -> return $ Just a
-      _ -> return Nothing
+masterWindow = MaybeT $
+  withWindowSet $ \ss ->
+    let windows = (S.integrate' . S.stack . S.workspace . S.current) ss
+     in case windows of
+          (a : _) -> return $ Just a
+          _ -> return Nothing
 
 windowsInWorkspace :: WorkspaceId -> X [Location]
 windowsInWorkspace wid =
   withWindowSet $
-    return . concatMap (\ws ->
-      if S.tag ws == wid
-        then map (Location wid . Just) $ S.integrate' (S.stack ws)
-        else []) . S.workspaces
+    return
+      . concatMap
+        ( \ws ->
+            if S.tag ws == wid
+              then map (Location wid . Just) $ S.integrate' (S.stack ws)
+              else []
+        )
+      . S.workspaces
 
 data WinPrompt = WinPrompt
 
 instance XPrompt WinPrompt where
-    showXPrompt _ = "[Window] "
-    commandToComplete _ = id
+  showXPrompt _ = "[Window] "
+  commandToComplete _ = id
 
 getString :: Window -> X String
 getString = runQuery $ do
@@ -107,7 +109,7 @@ withBorderWidth width ws fn = do
   forM_ ws $ \window ->
     io $ setWindowBorderWidth d window $ fromIntegral width
 
-  ret <- fn 
+  ret <- fn
 
   forM_ ws $ \window ->
     io $ setWindowBorderWidth d window 2
@@ -119,7 +121,7 @@ withBorderWidth width ws fn = do
 gotoWorkspace :: WorkspaceId -> X ()
 gotoWorkspace wid = windows $ S.greedyView wid
 
-moveLocationToWorkspace :: Location -> WorkspaceId ->  X ()
+moveLocationToWorkspace :: Location -> WorkspaceId -> X ()
 moveLocationToWorkspace (Location _ (Just win)) wid =
   windows $ S.shiftWin wid win
 moveLocationToWorkspace _ _ = return ()
@@ -136,4 +138,4 @@ getCurrentLocation = do
   return (Location ws win)
 
 runMaybeT_ :: (Monad m) => MaybeT m a -> m ()
-runMaybeT_  = void . runMaybeT
+runMaybeT_ = void . runMaybeT
diff --git a/src/Rahm/Desktop/DMenu.hs b/src/Rahm/Desktop/DMenu.hs
index d20d001..eeb0d5f 100644
--- a/src/Rahm/Desktop/DMenu.hs
+++ b/src/Rahm/Desktop/DMenu.hs
@@ -1,19 +1,20 @@
 module Rahm.Desktop.DMenu where
 
-import XMonad.Util.Dmenu
-import XMonad
 import Control.Monad
+import Data.List (intercalate)
 import Data.Map (Map)
 import qualified Data.Map as Map
-import XMonad.Util.Run
-import Data.List (intercalate)
 import Text.Printf (printf)
+import XMonad
+import XMonad.Util.Dmenu
+import XMonad.Util.Run
 
-data Colors =
-  Colors {
-    fg :: String,
-    bg :: String
-  }  | DefaultColors
+data Colors
+  = Colors
+      { fg :: String,
+        bg :: String
+      }
+  | DefaultColors
 
 menuCommand :: [String]
 menuCommand = ["rofi", "-monitor", "-4", "-i", "-dmenu", "-sort", "-levenshtein-sort"]
@@ -22,24 +23,37 @@ menuCommandString :: String
 menuCommandString = unwords menuCommand
 
 runDMenu :: X ()
-runDMenu = void $
-  safeSpawn
-    "rofi"
-    ["-monitor", "-4", "-display-run", "Execute", "-show", "run"]
+runDMenu =
+  void $
+    safeSpawn
+      "rofi"
+      ["-monitor", "-4", "-display-run", "Execute", "-show", "run"]
 
 runDMenuPrompt :: String -> Maybe String -> [String] -> X String
 runDMenuPrompt prompt color select =
   let realColor = maybe [] (\c -> ["-sb", c, "-nf", c]) color
-       in
-    runProcessWithInput "/home/rahm/.local/bin/dmenu_debug.sh" ([
-      "-p", prompt,
-      "-l", "12",
-      "-dim", "0.4" ]  ++ realColor) (intercalate "\n" select)
-
+   in runProcessWithInput
+        "/home/rahm/.local/bin/dmenu_debug.sh"
+        ( [ "-p",
+            prompt,
+            "-l",
+            "12",
+            "-dim",
+            "0.4"
+          ]
+            ++ realColor
+        )
+        (intercalate "\n" select)
 
 runDMenuPromptWithMap :: String -> Maybe String -> Map String a -> X (Maybe a)
 runDMenuPromptWithMap prompt color map = do
-  let realColor = maybe [] (
-          \c -> ["-theme-str", printf "* {theme-color: %s;}" c]) color
-  menuMapArgs (head menuCommand)
-    (tail menuCommand ++ ["-p", prompt] ++ realColor) map
+  let realColor =
+        maybe
+          []
+          ( \c -> ["-theme-str", printf "* {theme-color: %s;}" c]
+          )
+          color
+  menuMapArgs
+    (head menuCommand)
+    (tail menuCommand ++ ["-p", prompt] ++ realColor)
+    map
diff --git a/src/Rahm/Desktop/Desktop.hs b/src/Rahm/Desktop/Desktop.hs
index 053b330..5466fd1 100644
--- a/src/Rahm/Desktop/Desktop.hs
+++ b/src/Rahm/Desktop/Desktop.hs
@@ -4,22 +4,24 @@ module Rahm.Desktop.Desktop where
 -- state of the current screen -> workspace and thus restore it.
 
 -- import XMonad.Operations
-import Data.Maybe (fromMaybe)
+
 import Control.Monad (forM_)
-import XMonad (X(..))
-import qualified XMonad.StackSet as W
-import qualified XMonad as X
+import Data.Default
 import Data.Map (Map)
 import qualified Data.Map as Map
-import Data.Default
+import Data.Maybe (fromMaybe)
+import XMonad (X (..))
+import qualified XMonad as X
+import qualified XMonad.StackSet as W
 import qualified XMonad.Util.ExtensibleState as XS
 
 newtype Desktop si wi = Desktop (Map si wi)
   deriving (Read, Show)
 
-newtype Desktops = Desktops {
-  theaters :: Map String (Desktop X.ScreenId X.WorkspaceId)
-} deriving (Read, Show)
+newtype Desktops = Desktops
+  { theaters :: Map String (Desktop X.ScreenId X.WorkspaceId)
+  }
+  deriving (Read, Show)
 
 instance Default Desktops where
   def = Desktops mempty
@@ -32,9 +34,11 @@ saveCurrentDesktop :: String -> X ()
 saveCurrentDesktop name =
   X.withWindowSet $ \windowSet ->
     XS.modify $ \(Desktops m) ->
-      Desktops $ flip (Map.insert name) m $
-        Desktop $ Map.fromList $
-          map (\(W.Screen ws sid _) -> (sid, W.tag ws)) $ W.screens windowSet  
+      Desktops $
+        flip (Map.insert name) m $
+          Desktop $
+            Map.fromList $
+              map (\(W.Screen ws sid _) -> (sid, W.tag ws)) $ W.screens windowSet
 
 restoreDesktop :: String -> X ()
 restoreDesktop name = do
@@ -47,7 +51,7 @@ restoreDesktop name = do
             fromMaybe scr $ do
               wid <- Map.lookup (W.screen scr) screenToWorkspace
               workspace <- Map.lookup wid workspacesById
-              return $ scr { W.workspace = workspace }
+              return $ scr {W.workspace = workspace}
 
           newScreens = map newScreenWorkspace (cur : vis)
           newVisibleWorkspaces = map (W.tag . W.workspace) newScreens
@@ -55,6 +59,5 @@ restoreDesktop name = do
             filter (\ws -> not (W.tag ws `elem` newVisibleWorkspaces)) $
               W.workspaces ws
 
-          (newCur:newVisible) = newScreens
-        in
-          W.StackSet newCur newVisible newHiddenWorkspaces float
+          (newCur : newVisible) = newScreens
+       in W.StackSet newCur newVisible newHiddenWorkspaces float
diff --git a/src/Rahm/Desktop/Hash.hs b/src/Rahm/Desktop/Hash.hs
index dc58d96..abce660 100644
--- a/src/Rahm/Desktop/Hash.hs
+++ b/src/Rahm/Desktop/Hash.hs
@@ -1,11 +1,12 @@
 {-# LANGUAGE OverloadedStrings #-}
+
 module Rahm.Desktop.Hash where
 
-import Numeric (showHex)
+import qualified Crypto.Hash.SHA1 as SHA1
 import qualified Data.ByteString as BS
 import qualified Data.ByteString.Char8 as BC
-import qualified Crypto.Hash.SHA1 as SHA1
+import Numeric (showHex)
 
 quickHash :: String -> String
 quickHash str =
-    concatMap (`showHex` "") $ BS.unpack (SHA1.hash $ BC.pack str)
+  concatMap (`showHex` "") $ BS.unpack (SHA1.hash $ BC.pack str)
diff --git a/src/Rahm/Desktop/History.hs b/src/Rahm/Desktop/History.hs
index 516cd94..c5bc72d 100644
--- a/src/Rahm/Desktop/History.hs
+++ b/src/Rahm/Desktop/History.hs
@@ -1,19 +1,18 @@
 module Rahm.Desktop.History where
 
-import XMonad
-import Text.Printf
-import qualified Rahm.Desktop.StackSet as W
-import Data.IntMap (IntMap)
-import qualified Data.IntMap as IntMap
 import Data.Default
-import qualified XMonad.Util.ExtensibleState as XS
-
 import Data.Foldable (toList)
-import Rahm.Desktop.Hooks.WindowChange
+import Data.IntMap (IntMap)
+import qualified Data.IntMap as IntMap
+import Data.Sequence (Seq (..))
+import qualified Data.Sequence as Seq
 import Rahm.Desktop.Common
+import Rahm.Desktop.Hooks.WindowChange
 import Rahm.Desktop.Logger
-import Data.Sequence (Seq(..))
-import qualified Data.Sequence as Seq
+import qualified Rahm.Desktop.StackSet as W
+import Text.Printf
+import XMonad
+import qualified XMonad.Util.ExtensibleState as XS
 
 data BoundedSeqZipper a = BoundedSeqZipper Int (Seq a) (Seq a)
   deriving (Eq, Show, Ord, Read)
@@ -24,15 +23,15 @@ instance Functor BoundedSeqZipper where
 zipperDbgPrint :: (Show a) => BoundedSeqZipper a -> String
 zipperDbgPrint (BoundedSeqZipper _ h (c :<| t)) =
   concat $
-    map (printf " %s " . show) (toList h) ++
-    [printf "[%s]" (show c)] ++
-    map (printf " %s " . show) (toList t)
+    map (printf " %s " . show) (toList h)
+      ++ [printf "[%s]" (show c)]
+      ++ map (printf " %s " . show) (toList t)
 zipperDbgPrint _ = "<empty>"
 
 pushZipper :: a -> BoundedSeqZipper a -> BoundedSeqZipper a
 pushZipper e (BoundedSeqZipper maxSize _ (tail :|> _))
-    | maxSize <= Seq.length tail =
-  BoundedSeqZipper maxSize mempty (e :<| tail)
+  | maxSize <= Seq.length tail =
+    BoundedSeqZipper maxSize mempty (e :<| tail)
 pushZipper e (BoundedSeqZipper maxSize _ tail) =
   BoundedSeqZipper maxSize mempty (e :<| tail)
 
@@ -48,16 +47,18 @@ zipperForward :: BoundedSeqZipper a -> BoundedSeqZipper a
 zipperForward (BoundedSeqZipper s (e :<| h) t) = BoundedSeqZipper s h (e :<| t)
 zipperForward b = b
 
-newtype History = History {
-  currentZipper :: BoundedSeqZipper Location
-} deriving (Read, Show)
+newtype History = History
+  { currentZipper :: BoundedSeqZipper Location
+  }
+  deriving (Read, Show)
 
 instance Default History where
   def = History (BoundedSeqZipper 1000 mempty mempty)
 
 instance ExtensionClass History where
   initialValue = def
-  -- extensionType = PersistentExtension
+
+-- extensionType = PersistentExtension
 
 pastHistory :: Int -> X (Maybe Location)
 pastHistory i = do
@@ -72,7 +73,6 @@ getMostRecentLocationInHistory = do
     (BoundedSeqZipper _ _ (t :<| _)) -> return $ Just t
     _ -> return Nothing
 
-
 historyBack :: X ()
 historyBack = do
   History z <- XS.get
@@ -101,5 +101,4 @@ historyHook Nothing loc =
   XS.modify $ \(History z) -> History (pushZipper loc z)
 historyHook (Just (Location ws _)) l@(Location ws' _) | ws /= ws' = do
   XS.modify $ \(History z) -> History (pushZipper l z)
-
 historyHook _ _ = return ()
diff --git a/src/Rahm/Desktop/Hooks/WindowChange.hs b/src/Rahm/Desktop/Hooks/WindowChange.hs
index 3bc66a4..092fbf4 100644
--- a/src/Rahm/Desktop/Hooks/WindowChange.hs
+++ b/src/Rahm/Desktop/Hooks/WindowChange.hs
@@ -1,12 +1,11 @@
 module Rahm.Desktop.Hooks.WindowChange where
 
-import XMonad
 import Control.Monad
-import qualified XMonad.Util.ExtensibleState as XS
 import Data.Default
 import Rahm.Desktop.Common
-
 import qualified Rahm.Desktop.StackSet as W
+import XMonad
+import qualified XMonad.Util.ExtensibleState as XS
 
 newtype LastLocation = LastLocation (Maybe Location)
   deriving (Read, Show)
@@ -17,7 +16,7 @@ instance Default LastLocation where
 instance ExtensionClass LastLocation where
   initialValue = def
   extensionType = PersistentExtension
-  
+
 -- Creates a log hook from the function provided.
 --
 -- The first argument to the function is the old window, the second argument in
@@ -26,18 +25,18 @@ instance ExtensionClass LastLocation where
 -- If the first window is Nothing, this is the first time XMonad started.
 withLocationChangeHook :: (Maybe Location -> Location -> X ()) -> XConfig l -> XConfig l
 withLocationChangeHook fn config =
-  config {
-    logHook = do
-      logHook config
+  config
+    { logHook = do
+        logHook config
 
-      currentLocation <-
-        Location <$> getCurrentWorkspace <*> withWindowSet (return . W.peek)
+        currentLocation <-
+          Location <$> getCurrentWorkspace <*> withWindowSet (return . W.peek)
 
-      LastLocation last <- XS.get
+        LastLocation last <- XS.get
 
-      when (last /= Just currentLocation) $
-        fn last currentLocation
+        when (last /= Just currentLocation) $
+          fn last currentLocation
 
-      XS.put $ LastLocation $ Just currentLocation
-      return ()
-  }
+        XS.put $ LastLocation $ Just currentLocation
+        return ()
+    }
diff --git a/src/Rahm/Desktop/Keys.hs b/src/Rahm/Desktop/Keys.hs
index eae1c34..0ab868f 100644
--- a/src/Rahm/Desktop/Keys.hs
+++ b/src/Rahm/Desktop/Keys.hs
@@ -1,78 +1,75 @@
 module Rahm.Desktop.Keys (applyKeys) where
 
-import Control.Monad.Trans.Maybe
 import Control.Applicative
 import Control.Monad
 import Control.Monad.Fix (fix)
 import Control.Monad.Loops (iterateWhile)
 import Control.Monad.Reader
 import Control.Monad.Trans.Class
+import Control.Monad.Trans.Maybe
 import Control.Monad.Writer
 import Data.Char
 import Data.List hiding ((!!))
 import Data.List.Safe ((!!))
 import Data.Map (Map)
-import Data.Maybe (isJust, fromMaybe, mapMaybe)
-import Data.Monoid (Endo(..))
+import qualified Data.Map as Map
+import Data.Maybe (fromMaybe, isJust, mapMaybe)
+import Data.Monoid (Endo (..))
 import Data.Proxy
 import Debug.Trace
-import Graphics.X11.ExtraTypes.XF86;
+import Graphics.X11.ExtraTypes.XF86
 import Graphics.X11.ExtraTypes.XorgDefault
-import Prelude hiding ((!!))
-import System.IO
-import System.Process
-import Text.Printf
-import XMonad
-import XMonad.Actions.CopyWindow as CopyWindow
-import XMonad.Actions.RotSlaves
-import XMonad.Actions.SpawnOn as SpawnOn
-import XMonad.Actions.WindowNavigation
-import XMonad.Hooks.ManageDocks
-import XMonad.Layout.MosaicAlt
-import XMonad.Layout.Spacing
-import XMonad.Prompt
-import XMonad.Prompt.Input
-import XMonad.Prompt.Shell
-import XMonad.Util.XUtils
-import XMonad.Util.CustomKeys
-import XMonad.Util.Run (safeSpawn)
-import XMonad.Util.Scratchpad
-import XMonad.Util.Ungrab
 import Prettyprinter
-
-import qualified Data.Map as Map
-
+import Rahm.Desktop.Common
 import Rahm.Desktop.DMenu
+import Rahm.Desktop.Desktop
+import Rahm.Desktop.History
 import Rahm.Desktop.Keys.Dsl
+import Rahm.Desktop.Keys.Wml
 import Rahm.Desktop.Layout
 import Rahm.Desktop.Layout.Bordering
 import Rahm.Desktop.Layout.ConsistentMosaic
 import Rahm.Desktop.Layout.Flip (flipHorizontally, flipVertically)
 import Rahm.Desktop.Layout.Hole (toggleHole)
-import Rahm.Desktop.Layout.List (toNextLayout, toPreviousLayout, toFirstLayout, toIndexedLayout)
+import Rahm.Desktop.Layout.List (toFirstLayout, toIndexedLayout, toNextLayout, toPreviousLayout)
 import Rahm.Desktop.Layout.Pop (togglePop)
 import Rahm.Desktop.Layout.Rotate (rotateLayout)
-import Rahm.Desktop.Common
 import Rahm.Desktop.Logger
 import Rahm.Desktop.Marking
-import Rahm.Desktop.Keys.Wml
 import Rahm.Desktop.MouseMotion
 import Rahm.Desktop.PassMenu
 import Rahm.Desktop.PromptConfig
 import Rahm.Desktop.RebindKeys
+import qualified Rahm.Desktop.StackSet as W
 import Rahm.Desktop.Submap
 import Rahm.Desktop.Swallow
 import Rahm.Desktop.SwapMaster (swapMaster)
-import Rahm.Desktop.Workspaces
-import Rahm.Desktop.Desktop
 import Rahm.Desktop.Theater
-
-import qualified Rahm.Desktop.StackSet as W
-import Rahm.Desktop.History
+import Rahm.Desktop.Workspaces
+import System.IO
+import System.Process
+import Text.Printf
+import XMonad
+import XMonad.Actions.CopyWindow as CopyWindow
+import XMonad.Actions.RotSlaves
+import XMonad.Actions.SpawnOn as SpawnOn
+import XMonad.Actions.WindowNavigation
+import XMonad.Hooks.ManageDocks
+import XMonad.Layout.MosaicAlt
+import XMonad.Layout.Spacing
+import XMonad.Prompt
+import XMonad.Prompt.Input
+import XMonad.Prompt.Shell
+import XMonad.Util.CustomKeys
+import XMonad.Util.Run (safeSpawn)
+import XMonad.Util.Scratchpad
+import XMonad.Util.Ungrab
+import XMonad.Util.XUtils
+import Prelude hiding ((!!))
 
 type KeyMap l = XConfig l -> Map (KeyMask, KeySym) (X ())
-type ButtonsMap l = XConfig l -> Map (KeyMask, Button) (Window -> X ())
 
+type ButtonsMap l = XConfig l -> Map (KeyMask, Button) (Window -> X ())
 
 spawnX :: String -> X ()
 spawnX = spawn
@@ -84,17 +81,24 @@ noWindow :: b -> Window -> b
 noWindow = const
 
 decreaseVolume = spawnX "pactl set-sink-volume @DEFAULT_SINK@ -5%"
+
 increaseVolume = spawnX "pactl set-sink-volume @DEFAULT_SINK@ +5%"
+
 playPause = spawnX "spotify-control play"
+
 mediaPrev = spawnX "spotify-control prev"
+
 mediaNext = spawnX "spotify-control next"
 
 decreaseVolumeDoc = doc "Decrease volume" decreaseVolume
+
 increaseVolumeDoc = doc "Increase volume" increaseVolume
+
 playPauseDoc = doc "Play/Pause current media" playPause
+
 mediaPrevDoc = doc "Previous media" mediaPrev
-mediaNextDoc = doc "Next media" mediaNext
 
+mediaNextDoc = doc "Next media" mediaNext
 
 button6 :: Button
 button6 = 6
@@ -128,7 +132,6 @@ button15 = 15
 
 keyBindingToKeymap :: (XConfig l -> KeyBindings) -> KeyMap l
 keyBindingToKeymap bindings config = Map.mapWithKey bindingToX (bindings config)
-
   where
     bindingToX :: (KeyMask, KeySym) -> Documented KeyBinding -> X ()
     bindingToX key b =
@@ -151,11 +154,11 @@ keymap = runKeys $ do
   forM_ [xK_apostrophe, xK_w] $ \k -> bind k $ do
     justMod $
       doc "Jumps between marks." $
-      runMaybeT_ $ do
-        l <- readNextLocationSet
-        case l of
-          (h:_) -> lift (focusLocation h)
-          _ -> return ()
+        runMaybeT_ $ do
+          l <- readNextLocationSet
+          case l of
+            (h : _) -> lift (focusLocation h)
+            _ -> return ()
 
   bind xK_BackSpace $ do
     -- The only raw keybinding. Meant to get a terminal to unbrick XMonad if
@@ -163,12 +166,12 @@ keymap = runKeys $ do
     -- where dmenu/alacritty may not be installed.
     rawMask mod4Mask $
       doc "Spawns XTerm as a fallback if xkb is messed up." $
-      spawnX "xterm"
+        spawnX "xterm"
 
     -- Moves xmobar to different monitors.
     justMod $
       doc "Move XMobar to another screen." $
-      spawnX "pkill -SIGUSR1 xmobar"
+        spawnX "pkill -SIGUSR1 xmobar"
 
   bind xK_F1 $ do
     -- Experimental. Sends 'a' to all windows.
@@ -178,21 +181,32 @@ keymap = runKeys $ do
     -- focused. It's pretty annoying because it keeps me from doing some cool
     -- things all for BS security theater, but I guess there might be some way
     -- to do this via XTest?
-    shiftMod $ withWindowSet $ mapM_  (\w -> do
-      logs Info "Try send to %s" (show w)
-      sendKey (0, xK_a) w) . W.allWindows
+    shiftMod $
+      withWindowSet $
+        mapM_
+          ( \w -> do
+              logs Info "Try send to %s" (show w)
+              sendKey (0, xK_a) w
+          )
+          . W.allWindows
 
     justMod $
-      doc "Print this documentation"
-      (safeSpawn "gxmessage" [
-        "-fn", "Source Code Pro",
-        documentation (keymap config)] :: X ())
+      doc
+        "Print this documentation"
+        ( safeSpawn
+            "gxmessage"
+            [ "-fn",
+              "Source Code Pro",
+              documentation (keymap config)
+            ] ::
+            X ()
+        )
 
   bind xK_F7 $
-
     justMod $
-      doc "Print this documentation."
-      (logs Info "%s" (documentation (keymap config)) :: X ())
+      doc
+        "Print this documentation."
+        (logs Info "%s" (documentation (keymap config)) :: X ())
 
   bind xK_F10 $ do
     justMod playPauseDoc
@@ -207,25 +221,25 @@ keymap = runKeys $ do
     justMod swapMaster
 
   bind xK_Tab $ do
-    justMod  $ windows W.focusDown
+    justMod $ windows W.focusDown
     shiftMod $ windows W.focusUp
 
   -- Switch between different screens. These are the leftmost keys on the home
   -- row in a Dvorak layout. One might want to switch these to ASD for QWERTY.
-  forM_ (zip [xK_a, xK_o, xK_e] [0..]) $ \(key, idx) ->
+  forM_ (zip [xK_a, xK_o, xK_e] [0 ..]) $ \(key, idx) ->
     bind key $ do
       -- Move focus to that screen.
-      justMod  $
+      justMod $
         doc ("Switch focus to screen " ++ show idx) $
-        withScreen W.view idx
+          withScreen W.view idx
       -- Swap the current screen with the one given
-      altMod   $
+      altMod $
         doc ("Swap the current screen with screen " ++ show idx) $
-        withScreen W.greedyView idx
+          withScreen W.greedyView idx
       -- Move the current window to the select screen.
       shiftMod $
         doc ("Move the current window to screne " ++ show idx) $
-        withScreen W.shift idx
+          withScreen W.shift idx
 
       altgrMod
         (logs Info "Test altgr" :: X ())
@@ -233,12 +247,12 @@ keymap = runKeys $ do
   bind xK_bracketright $ do
     justMod $
       doc "Increase the gaps between windows." $
-      sendMessage $ modifyWindowBorder 5
+        sendMessage $ modifyWindowBorder 5
 
   bind xK_bracketleft $ do
     justMod $
       doc "Decrease the gaps between windows." $
-      sendMessage $ modifyWindowBorder (-5)
+        sendMessage $ modifyWindowBorder (-5)
 
   bind xK_b $ do
     justMod $ spawnX "bluetooth-select.sh"
@@ -251,45 +265,43 @@ keymap = runKeys $ do
       doc "Kill the current window" CopyWindow.kill1
 
   bind xK_f $ do
-    justMod  $
+    justMod $
       doc "Flip the current layout vertically" $
-      sendMessage flipVertically
+        sendMessage flipVertically
     shiftMod $
       doc "Flip the current layout horizontally" $
-      sendMessage flipHorizontally
+        sendMessage flipHorizontally
 
   bind xK_g $ do
-
     justMod $
-      doc "Goto/Send/Etc To a workspace\n\n\t\
-
-      \Workspaces are alphanumeric characters. So if the next key typed is an\n\t\
-      \alphanumeric character, that's the workspace to operate on\n\n\
-
-      \\tThe following special characters can also reference workspaces:\n\t\t\
-         \]: The next workspace, skipping those already visible.\n\t\t\
-         \[: The previous workspace, skipping those already visible.\n\t\t\
-         \): The next workspace.\n\t\t\
-         \(: The previous workspace.\n\t\t\
-         \}: The workspace on the screen to the right\n\t\t\
-         \{: The workspace on the screen to the left\n\t\t\
-         \<space>: The accompaningWorkspace (toggled case)\n\t\t\
-         \/: Prompt to select a window, and reference that workspace\n\t\t\
-         \^: The first populated workspace\n\t\t\
-         \$: The last populated workspace\n\t\t\
-         \*: The hidden workspace.\n\t\t\
-         \_: Black hole. Sending a window here closes it.\n\n\t\
-      \Other keybindings starting with H-g\n\t\t\
-         \F1: display this help.\n\n\t" $
-      runMaybeT_ $ (lift . gotoWorkspaceFn) =<< readNextWorkspace
+      doc
+        "Goto/Send/Etc To a workspace\n\n\t\
+        \Workspaces are alphanumeric characters. So if the next key typed is an\n\t\
+        \alphanumeric character, that's the workspace to operate on\n\n\
+        \\tThe following special characters can also reference workspaces:\n\t\t\
+        \]: The next workspace, skipping those already visible.\n\t\t\
+        \[: The previous workspace, skipping those already visible.\n\t\t\
+        \): The next workspace.\n\t\t\
+        \(: The previous workspace.\n\t\t\
+        \}: The workspace on the screen to the right\n\t\t\
+        \{: The workspace on the screen to the left\n\t\t\
+        \<space>: The accompaningWorkspace (toggled case)\n\t\t\
+        \/: Prompt to select a window, and reference that workspace\n\t\t\
+        \^: The first populated workspace\n\t\t\
+        \$: The last populated workspace\n\t\t\
+        \*: The hidden workspace.\n\t\t\
+        \_: Black hole. Sending a window here closes it.\n\n\t\
+        \Other keybindings starting with H-g\n\t\t\
+        \F1: display this help.\n\n\t"
+        $ runMaybeT_ $ (lift . gotoWorkspaceFn) =<< readNextWorkspace
 
     controlMod $