Refer to modm as the current modMask

This makes the config suggestions consistent with the current template.

XMonad/Actions/Commands.hs

@@ -41,7 +41,7 @@ import Data.Maybe
 --
 -- Then add a keybinding to the runCommand action:
 --
--- >    , ((modMask x .|. controlMask, xK_y), commands >>= runCommand)
+-- >    , ((modm .|. controlMask, xK_y), commands >>= runCommand)
 --
 -- and define the list of commands you want to use:
 --

XMonad/Actions/ConstrainedResize.hs

@@ -31,8 +31,8 @@ import XMonad
 --
 -- Then add something like the following to your mouse bindings:
 --
--- >     , ((modMask x, button3),               (\w -> focus w >> Sqr.mouseResizeWindow w False))
+-- >     , ((modm, button3),               (\w -> focus w >> Sqr.mouseResizeWindow w False))
--- >     , ((modMask x .|. shiftMask, button3), (\w -> focus w >> Sqr.mouseResizeWindow w True ))
+-- >     , ((modm .|. shiftMask, button3), (\w -> focus w >> Sqr.mouseResizeWindow w True ))
 --
 -- The line without the shiftMask replaces the standard mouse resize
 -- function call, so it's not completely necessary but seems neater

XMonad/Actions/CopyWindow.hs

@@ -43,7 +43,7 @@ import qualified XMonad.StackSet as W
 -- > -- mod-[1..9] @@ Switch to workspace N
 -- > -- mod-shift-[1..9] @@ Move client to workspace N
 -- > -- mod-control-shift-[1..9] @@ Copy client to workspace N
--- > [((m .|. modMask x, k), windows $ f i)
+-- > [((m .|. modm, k), windows $ f i)
 -- >     | (i, k) <- zip (workspaces x) [xK_1 ..]
 -- >     , (f, m) <- [(W.view, 0), (W.shift, shiftMask), (copy, shiftMask .|. controlMask)]]
 --
@@ -55,12 +55,12 @@ import qualified XMonad.StackSet as W
 -- You may also wish to redefine the binding to kill a window so it only
 -- removes it from the current workspace, if it's present elsewhere:
 --
--- >  , ((modMask x .|. shiftMask, xK_c     ), kill1) -- @@ Close the focused window
+-- >  , ((modm .|. shiftMask, xK_c     ), kill1) -- @@ Close the focused window
 --
 -- Instead of copying a window from one workspace to another maybe you don't
 -- want to have to remember where you placed it.  For that consider:
 --
--- >  , ((modMask x, xK_b    ), runOrCopy "firefox" (className =? "Firefox")) -- @@ run or copy firefox
+-- >  , ((modm, xK_b    ), runOrCopy "firefox" (className =? "Firefox")) -- @@ run or copy firefox
 --
 -- Another possibility which this extension provides is 'making window
 -- always visible' (i.e. always on current workspace), similar to corresponding
@@ -70,8 +70,8 @@ import qualified XMonad.StackSet as W
 --
 -- Here is the example of keybindings which provide these actions:
 --
--- >  , ((modMask x, xK_v ), windows copyToAll) -- @@ Make focused window always visible
+-- >  , ((modm, xK_v ), windows copyToAll) -- @@ Make focused window always visible
--- >  , ((modMask x .|. shiftMask, xK_v ),  killAllOtherCopies) -- @@ Toggle window state back
+-- >  , ((modm .|. shiftMask, xK_v ),  killAllOtherCopies) -- @@ Toggle window state back
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/CycleRecentWS.hs

@@ -30,7 +30,7 @@ import XMonad.StackSet
 --
 -- > import XMonad.Actions.CycleRecentWS
 -- >
--- >   , ((modMask x, xK_Tab), cycleRecentWS [xK_Alt_L] xK_Tab xK_grave)
+-- >   , ((modm, xK_Tab), cycleRecentWS [xK_Alt_L] xK_Tab xK_grave)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/CycleSelectedLayouts.hs

@@ -30,7 +30,7 @@ import qualified XMonad.StackSet as S
 -- > import XMonad.Layout.LayoutCombinators ((|||))
 -- > import XMonad.Actions.CycleSelectedLayouts
 --
--- >   , ((modMask x,  xK_t ),   cycleThroughLayouts ["Tall", "Mirror Tall"])
+-- >   , ((modm,  xK_t ),   cycleThroughLayouts ["Tall", "Mirror Tall"])
 --
 -- Make sure you are using NewSelect from XMonad.Layout.LayoutCombinators,
 -- rather than the Select defined in xmonad core.

XMonad/Actions/CycleWS.hs

@@ -90,26 +90,26 @@ import XMonad.Util.WorkspaceCompare
 -- >
 -- > -- a basic CycleWS setup
 -- >
--- >   , ((modMask x,               xK_Down),  nextWS)
+-- >   , ((modm,               xK_Down),  nextWS)
--- >   , ((modMask x,               xK_Up),    prevWS)
+-- >   , ((modm,               xK_Up),    prevWS)
--- >   , ((modMask x .|. shiftMask, xK_Down),  shiftToNext)
+-- >   , ((modm .|. shiftMask, xK_Down),  shiftToNext)
--- >   , ((modMask x .|. shiftMask, xK_Up),    shiftToPrev)
+-- >   , ((modm .|. shiftMask, xK_Up),    shiftToPrev)
--- >   , ((modMask x,               xK_Right), nextScreen)
+-- >   , ((modm,               xK_Right), nextScreen)
--- >   , ((modMask x,               xK_Left),  prevScreen)
+-- >   , ((modm,               xK_Left),  prevScreen)
--- >   , ((modMask x .|. shiftMask, xK_Right), shiftNextScreen)
+-- >   , ((modm .|. shiftMask, xK_Right), shiftNextScreen)
--- >   , ((modMask x .|. shiftMask, xK_Left),  shiftPrevScreen)
+-- >   , ((modm .|. shiftMask, xK_Left),  shiftPrevScreen)
--- >   , ((modMask x,               xK_z),     toggleWS)
+-- >   , ((modm,               xK_z),     toggleWS)
 --
 -- If you want to follow the moved window, you can use both actions:
 --
--- >   , ((modMask x .|. shiftMask, xK_Down), shiftToNext >> nextWS)
+-- >   , ((modm .|. shiftMask, xK_Down), shiftToNext >> nextWS)
--- >   , ((modMask x .|. shiftMask, xK_Up),   shiftToPrev >> prevWS)
+-- >   , ((modm .|. shiftMask, xK_Up),   shiftToPrev >> prevWS)
 --
 -- You can also get fancier with 'moveTo', 'shiftTo', and 'findWorkspace'.
 -- For example:
 --
--- >   , ((modMask x     , xK_f), moveTo Next EmptyWS)  -- find a free workspace
+-- >   , ((modm     , xK_f), moveTo Next EmptyWS)  -- find a free workspace
--- >   , ((modMask x .|. controlMask, xK_Right),        -- a crazy keybinding!
+-- >   , ((modm .|. controlMask, xK_Right),        -- a crazy keybinding!
 -- >         do t <- findWorkspace getSortByXineramaRule Next NonEmptyWS 2
 -- >            windows . view $ t                                         )
 --

XMonad/Actions/CycleWindows.hs

@@ -64,11 +64,11 @@ import Control.Arrow (second)
 -- >
 -- >              -- make sure mod matches keysym
 -- >  , ((mod4Mask,  xK_s), cycleRecentWindows [xK_Super_L] xK_s xK_w)
--- >  , ((modMask x, xK_z), rotOpposite)
+-- >  , ((modm, xK_z), rotOpposite)
--- >  , ((modMask x                , xK_i), rotUnfocusedUp)
+-- >  , ((modm                , xK_i), rotUnfocusedUp)
--- >  , ((modMask x                , xK_u), rotUnfocusedDown)
+-- >  , ((modm                , xK_u), rotUnfocusedDown)
--- >  , ((modMask x .|. controlMask, xK_i), rotFocusedUp)
+-- >  , ((modm .|. controlMask, xK_i), rotFocusedUp)
--- >  , ((modMask x .|. controlMask, xK_u), rotFocusedDown)
+-- >  , ((modm .|. controlMask, xK_u), rotFocusedDown)
 --
 -- Also, if you use focus follows mouse, you will want to read the section
 -- on updating the mouse pointer below.  For detailed instructions on
@@ -88,9 +88,9 @@ to the point of your choice on the current window:
 and either
 
 > -- modify the window rotation bindings
-> , ((modMask x .|. controlMask, xK_i   ), rotFocusedUp
+> , ((modm .|. controlMask, xK_i   ), rotFocusedUp
 >                                            >> updatePointer (Relative 1 1))
-> , ((modMask x .|. controlMask, xK_u   ), rotFocusedDown
+> , ((modm .|. controlMask, xK_u   ), rotFocusedDown
 >                                            >> updatePointer (Relative 1 1))
 >
 >    -- or add to xmonad's logHook

XMonad/Actions/DeManage.hs

@@ -44,7 +44,7 @@ import XMonad
 --
 -- And add a keybinding, such as:
 --
--- > , ((modMask x,               xK_d     ), withFocused demanage)
+-- > , ((modm,               xK_d     ), withFocused demanage)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/DwmPromote.hs

@@ -33,7 +33,7 @@ import XMonad.StackSet
 --
 -- then add a keybinding or substitute 'dwmpromote' in place of promote:
 --
--- >   , ((modMask x,               xK_Return), dwmpromote)
+-- >   , ((modm,               xK_Return), dwmpromote)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/DynamicWorkspaces.hs

@@ -36,18 +36,18 @@ import XMonad.Util.WorkspaceCompare ( getSortByIndex )
 --
 -- Then add keybindings like the following:
 --
--- >   , ((modMask x .|. shiftMask, xK_BackSpace), removeWorkspace)
+-- >   , ((modm .|. shiftMask, xK_BackSpace), removeWorkspace)
--- >   , ((modMask x .|. shiftMask, xK_v      ), selectWorkspace defaultXPConfig)
+-- >   , ((modm .|. shiftMask, xK_v      ), selectWorkspace defaultXPConfig)
--- >   , ((modMask x, xK_m                    ), withWorkspace defaultXPConfig (windows . W.shift))
+-- >   , ((modm, xK_m                    ), withWorkspace defaultXPConfig (windows . W.shift))
--- >   , ((modMask x .|. shiftMask, xK_m      ), withWorkspace defaultXPConfig (windows . copy))
+-- >   , ((modm .|. shiftMask, xK_m      ), withWorkspace defaultXPConfig (windows . copy))
--- >   , ((modMask x .|. shiftMask, xK_r      ), renameWorkspace defaultXPConfig)
+-- >   , ((modm .|. shiftMask, xK_r      ), renameWorkspace defaultXPConfig)
 --
 -- > -- mod-[1..9]       %! Switch to workspace N
 -- > -- mod-shift-[1..9] %! Move client to workspace N
 -- >    ++
--- >    zip (zip (repeat (modMask x)) [xK_1..xK_9]) (map (withNthWorkspace W.greedyView) [0..])
+-- >    zip (zip (repeat (modm)) [xK_1..xK_9]) (map (withNthWorkspace W.greedyView) [0..])
 -- >    ++
--- >    zip (zip (repeat (modMask x .|. shiftMask)) [xK_1..xK_9]) (map (withNthWorkspace W.shift) [0..])
+-- >    zip (zip (repeat (modm .|. shiftMask)) [xK_1..xK_9]) (map (withNthWorkspace W.shift) [0..])
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/FindEmptyWorkspace.hs

@@ -32,8 +32,8 @@ import XMonad.StackSet
 --
 -- and add the desired keybindings, for example:
 --
---  >   , ((modMask x,                xK_m    ), viewEmptyWorkspace)
+--  >   , ((modm,                xK_m    ), viewEmptyWorkspace)
---  >   , ((modMask x .|. shiftMask,  xK_m    ), tagToEmptyWorkspace)
+--  >   , ((modm .|. shiftMask,  xK_m    ), tagToEmptyWorkspace)
 --
 -- Now you can jump to an empty workspace with @mod-m@. @Mod-shift-m@
 -- will tag the current window to an empty workspace and view it.

XMonad/Actions/FlexibleManipulate.hs

@@ -31,7 +31,7 @@ import XMonad
 --
 -- Now set up the desired mouse binding, for example:
 --
--- >     , ((modMask x, button1), (\w -> focus w >> Flex.mouseWindow Flex.linear w))
+-- >     , ((modm, button1), (\w -> focus w >> Flex.mouseWindow Flex.linear w))
 --
 -- * Flex.'linear' indicates that positions between the edges and the
 --   middle indicate a combination scale\/position.

XMonad/Actions/FlexibleResize.hs

@@ -29,7 +29,7 @@ import Foreign.C.Types
 --
 -- Then add an appropriate mouse binding:
 --
--- >     , ((modMask x, button3), (\w -> focus w >> Flex.mouseResizeWindow w))
+-- >     , ((modm, button3), (\w -> focus w >> Flex.mouseResizeWindow w))
 --
 -- For detailed instructions on editing your mouse bindings, see
 -- "XMonad.Doc.Extending#Editing_mouse_bindings".

XMonad/Actions/FloatKeys.hs

@@ -28,11 +28,11 @@ import XMonad
 --
 -- Then add appropriate key bindings, for example:
 --
--- >  , ((modMask x,               xK_d     ), withFocused (keysResizeWindow (-10,-10) (1,1)))
+-- >  , ((modm,               xK_d     ), withFocused (keysResizeWindow (-10,-10) (1,1)))
--- >  , ((modMask x,               xK_s     ), withFocused (keysResizeWindow (10,10) (1,1)))
+-- >  , ((modm,               xK_s     ), withFocused (keysResizeWindow (10,10) (1,1)))
--- >  , ((modMask x .|. shiftMask, xK_d     ), withFocused (keysAbsResizeWindow (-10,-10) (1024,752)))
+-- >  , ((modm .|. shiftMask, xK_d     ), withFocused (keysAbsResizeWindow (-10,-10) (1024,752)))
--- >  , ((modMask x .|. shiftMask, xK_s     ), withFocused (keysAbsResizeWindow (10,10) (1024,752)))
+-- >  , ((modm .|. shiftMask, xK_s     ), withFocused (keysAbsResizeWindow (10,10) (1024,752)))
--- >  , ((modMask x,               xK_a     ), withFocused (keysMoveWindowTo (512,384) (1%2,1%2)))
+-- >  , ((modm,               xK_a     ), withFocused (keysMoveWindowTo (512,384) (1%2,1%2)))
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/FloatSnap.hs

@@ -41,23 +41,23 @@ import qualified Data.Set as S
 --
 -- Then add appropriate key bindings, for example:
 --
--- >        , ((modMask x,               xK_Left),  withFocused $ snapMove L Nothing)
+-- >        , ((modm,               xK_Left),  withFocused $ snapMove L Nothing)
--- >        , ((modMask x,               xK_Right), withFocused $ snapMove R Nothing)
+-- >        , ((modm,               xK_Right), withFocused $ snapMove R Nothing)
--- >        , ((modMask x,               xK_Up),    withFocused $ snapMove U Nothing)
+-- >        , ((modm,               xK_Up),    withFocused $ snapMove U Nothing)
--- >        , ((modMask x,               xK_Down),  withFocused $ snapMove D Nothing)
+-- >        , ((modm,               xK_Down),  withFocused $ snapMove D Nothing)
--- >        , ((modMask x .|. shiftMask, xK_Left),  withFocused $ snapShrink R Nothing)
+-- >        , ((modm .|. shiftMask, xK_Left),  withFocused $ snapShrink R Nothing)
--- >        , ((modMask x .|. shiftMask, xK_Right), withFocused $ snapGrow R Nothing)
+-- >        , ((modm .|. shiftMask, xK_Right), withFocused $ snapGrow R Nothing)
--- >        , ((modMask x .|. shiftMask, xK_Up),    withFocused $ snapShrink D Nothing)
+-- >        , ((modm .|. shiftMask, xK_Up),    withFocused $ snapShrink D Nothing)
--- >        , ((modMask x .|. shiftMask, xK_Down),  withFocused $ snapGrow D Nothing)
+-- >        , ((modm .|. shiftMask, xK_Down),  withFocused $ snapGrow D Nothing)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".
 --
 -- And possibly add an appropriate mouse binding, for example:
 --
--- >        , ((modMask x,               button1), (\w -> focus w >> mouseMoveWindow w >> snapMagicMove (Just 50) (Just 50) w))
+-- >        , ((modm,               button1), (\w -> focus w >> mouseMoveWindow w >> snapMagicMove (Just 50) (Just 50) w))
--- >        , ((modMask x .|. shiftMask, button1), (\w -> focus w >> mouseMoveWindow w >> snapMagicResize [L,R,U,D] (Just 50) (Just 50) w))
+-- >        , ((modm .|. shiftMask, button1), (\w -> focus w >> mouseMoveWindow w >> snapMagicResize [L,R,U,D] (Just 50) (Just 50) w))
--- >        , ((modMask x,               button3), (\w -> focus w >> mouseResizeWindow w >> snapMagicResize [R,D] (Just 50) (Just 50) w))
+-- >        , ((modm,               button3), (\w -> focus w >> mouseResizeWindow w >> snapMagicResize [R,D] (Just 50) (Just 50) w))
 --
 -- For detailed instructions on editing your mouse bindings, see
 -- "XMonad.Doc.Extending#Editing_mouse_bindings".

XMonad/Actions/FocusNth.hs

@@ -27,7 +27,7 @@ import XMonad
 -- Then add appropriate keybindings, for example:
 --
 -- > -- mod4-[1..9] @@ Switch to window N
--- > ++ [((modMask x, k), focusNth i)
+-- > ++ [((modm, k), focusNth i)
 -- >     | (i, k) <- zip [0 .. 8] [xK_1 ..]]
 --
 -- For detailed instructions on editing your key bindings, see

XMonad/Actions/GridSelect.hs

@@ -76,13 +76,13 @@ import Data.Word (Word8)
 --
 -- Then add a keybinding, e.g.
 --
--- >    , ((modMask x, xK_g), goToSelected defaultGSConfig)
+-- >    , ((modm, xK_g), goToSelected defaultGSConfig)
 --
 -- This module also supports displaying arbitrary information in a grid and letting
 -- the user select from it. E.g. to spawn an application from a given list, you
 -- can use the following:
 --
--- >   , ((modMask x, xK_s), spawnSelected defaultGSConfig ["xterm","gmplayer","gvim"])
+-- >   , ((modm, xK_s), spawnSelected defaultGSConfig ["xterm","gmplayer","gvim"])
 
 -- $commonGSConfig
 --
@@ -112,8 +112,8 @@ import Data.Word (Word8)
 --
 -- Then you can bind to:
 --
--- >     ,((modMask x, xK_g), goToSelected  $ gsconfig2 myWinColorizer)
+-- >     ,((modm, xK_g), goToSelected  $ gsconfig2 myWinColorizer)
--- >     ,((modMask x, xK_p), spawnSelected $ spawnSelected defaultColorizer)
+-- >     ,((modm, xK_p), spawnSelected $ spawnSelected defaultColorizer)
 
 -- $keybindings
 --

XMonad/Actions/MouseGestures.hs

@@ -39,7 +39,7 @@ import Control.Monad
 --
 -- then add an appropriate mouse binding:
 --
--- >     , ((modMask x .|. shiftMask, button3), mouseGesture gestures)
+-- >     , ((modm .|. shiftMask, button3), mouseGesture gestures)
 --
 -- where @gestures@ is a 'Data.Map.Map' from gestures to actions on
 -- windows, for example:

XMonad/Actions/NoBorders.hs

@@ -21,7 +21,7 @@ import XMonad
 -- | Toggle the border of the currently focused window. To use it, add a
 -- keybinding like so:
 --
--- > , ((modMask x,  xK_g ),   withFocused toggleBorder)
+-- > , ((modm,  xK_g ),   withFocused toggleBorder)
 --
 toggleBorder :: Window -> X ()
 toggleBorder w = do

XMonad/Actions/OnScreen.hs

@@ -39,7 +39,7 @@ import Data.Function(on)
 -- to switch the workspaces with this at the bottom of your keybindings:
 --
 -- >     ++
--- >     [ ((m .|. modMask, k), windows (f i))
+-- >     [ ((m .|. modm, k), windows (f i))
 -- >       | (i, k) <- zip (workspaces conf) ([xK_1 .. xK_9] ++ [xK_0])
 -- >       , (f, m) <- [ (viewOnScreen 0, 0)
 -- >                   , (viewOnScreen 1, controlMask)
@@ -60,7 +60,7 @@ import Data.Function(on)
 --
 -- A more basic version inside the default keybindings would be:
 --
--- >        , ((modMask .|. controlMask, xK_1) windows (viewOnScreen 0 "1"))
+-- >        , ((modm .|. controlMask, xK_1) windows (viewOnScreen 0 "1"))
 --
 -- where 0 is the first screen and "1" the workspace with the tag "1".
 --

XMonad/Actions/PhysicalScreens.hs

@@ -48,7 +48,7 @@ Example usage in your @~\/.xmonad\/xmonad.hs@ file:
 > -- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3
 > -- mod-shift-{w,e,r}, Move client to screen 1, 2, or 3
 > --
-> [((modMask .|. mask, key), f sc)
+> [((modm .|. mask, key), f sc)
 >     | (key, sc) <- zip [xK_w, xK_e, xK_r] [0..]
 >     , (f, mask) <- [(viewScreen, 0), (sendToScreen, shiftMask)]]
 

XMonad/Actions/Promote.hs

@@ -33,7 +33,7 @@ import XMonad.StackSet
 --
 -- then add a keybinding or substitute 'promote' in place of swapMaster:
 --
--- >   , ((modMask x,               xK_Return), promote)
+-- >   , ((modm,               xK_Return), promote)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/RotSlaves.hs

@@ -28,7 +28,7 @@ import XMonad
 --
 -- and add whatever keybindings you would like, for example:
 --
--- > , ((modMask x .|. shiftMask, xK_Tab   ), rotSlavesUp)
+-- > , ((modm .|. shiftMask, xK_Tab   ), rotSlavesUp)
 --
 -- This operation will rotate all windows except the master window,
 -- while the focus stays where it is. It is useful together with the

XMonad/Actions/SimpleDate.hs

@@ -29,7 +29,7 @@ import XMonad.Util.Run
 --
 -- and add a keybinding, for example:
 --
--- >    , ((modMask x,               xK_d     ), date)
+-- >    , ((modm,               xK_d     ), date)
 --
 -- In this example, a popup date menu will now be bound to @mod-d@.
 --

XMonad/Actions/SinkAll.hs

@@ -28,7 +28,7 @@ import XMonad.Actions.WithAll (sinkAll)
 --
 -- then add a keybinding; for example:
 --
---     , ((modMask x .|. shiftMask, xK_t), sinkAll)
+-- >   , ((modm .|. shiftMask, xK_t), sinkAll)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/Submap.hs

@@ -34,7 +34,7 @@ First, import this module into your @~\/.xmonad\/xmonad.hs@:
 
 Allows you to create a sub-mapping of keys. Example:
 
->    , ((modMask x, xK_a), submap . M.fromList $
+>    , ((modm, xK_a), submap . M.fromList $
 >        [ ((0, xK_n),     spawn "mpc next")
 >        , ((0, xK_p),     spawn "mpc prev")
 >        , ((0, xK_z),     spawn "mpc random")

XMonad/Actions/SwapWorkspaces.hs

@@ -37,7 +37,7 @@ import XMonad.Util.WorkspaceCompare
 -- Then throw something like this in your keys definition:
 --
 -- > ++
--- > [((modMask x .|. controlMask, k), windows $ swapWithCurrent i)
+-- > [((modm .|. controlMask, k), windows $ swapWithCurrent i)
 -- >     | (i, k) <- zip workspaces [xK_1 ..]]
 --
 -- After installing this update, if you're on workspace 1, hitting mod-ctrl-5

XMonad/Actions/TagWindows.hs

@@ -42,15 +42,15 @@ import XMonad hiding (workspaces)
 --
 -- and add keybindings such as the following:
 --
--- >   , ((modMask x,                 xK_f  ), withFocused (addTag "abc"))
+-- >   , ((modm,                 xK_f  ), withFocused (addTag "abc"))
--- >   , ((modMask x .|. controlMask, xK_f  ), withFocused (delTag "abc"))
+-- >   , ((modm .|. controlMask, xK_f  ), withFocused (delTag "abc"))
--- >   , ((modMask x .|. shiftMask,   xK_f  ), withTaggedGlobalP "abc" W.sink)
+-- >   , ((modm .|. shiftMask,   xK_f  ), withTaggedGlobalP "abc" W.sink)
--- >   , ((modMask x,                 xK_d  ), withTaggedP "abc" (W.shiftWin "2"))
+-- >   , ((modm,                 xK_d  ), withTaggedP "abc" (W.shiftWin "2"))
--- >   , ((modMask x .|. shiftMask,   xK_d  ), withTaggedGlobalP "abc" shiftHere)
+-- >   , ((modm .|. shiftMask,   xK_d  ), withTaggedGlobalP "abc" shiftHere)
--- >   , ((modMask x .|. controlMask, xK_d  ), focusUpTaggedGlobal "abc")
+-- >   , ((modm .|. controlMask, xK_d  ), focusUpTaggedGlobal "abc")
--- >   , ((modMask x,                 xK_g  ), tagPrompt defaultXPConfig (\s -> withFocused (addTag s)))
+-- >   , ((modm,                 xK_g  ), tagPrompt defaultXPConfig (\s -> withFocused (addTag s)))
--- >   , ((modMask x .|. controlMask, xK_g  ), tagDelPrompt defaultXPConfig)
+-- >   , ((modm .|. controlMask, xK_g  ), tagDelPrompt defaultXPConfig)
--- >   , ((modMask x .|. shiftMask,   xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedGlobal s float))
+-- >   , ((modm .|. shiftMask,   xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedGlobal s float))
 -- >   , ((modWinMask,                xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedP s (W.shiftWin "2")))
 -- >   , ((modWinMask .|. shiftMask,  xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedGlobalP s shiftHere))
 -- >   , ((modWinMask .|. controlMask, xK_g ), tagPrompt defaultXPConfig (\s -> focusUpTaggedGlobal s))

XMonad/Actions/TopicSpace.hs

@@ -136,15 +136,15 @@ import XMonad.Util.StringProp(getStringListProp,setStringListProp)
 --
 -- @
 --  -- extend your keybindings
---  myKeys =
+--  myKeys conf\@XConfig{modMask=modm} =
---    [ ((modMask              , xK_n     ), spawnShell) -- %! Launch terminal
+--    [ ((modm              , xK_n     ), spawnShell) -- %! Launch terminal
---    , ((modMask              , xK_a     ), currentTopicAction myTopicConfig)
+--    , ((modm              , xK_a     ), currentTopicAction myTopicConfig)
---    , ((modMask              , xK_g     ), promptedGoto)
+--    , ((modm              , xK_g     ), promptedGoto)
---    , ((modMask .|. shiftMask, xK_g     ), promptedShift)
+--    , ((modm .|. shiftMask, xK_g     ), promptedShift)
 --    ...
 --    ]
 --    ++
---    [ ((modMask, k), switchNthLastFocused myTopicConfig i)
+--    [ ((modm, k), switchNthLastFocused myTopicConfig i)
 --    | (i, k) <- zip [1..] workspaceKeys]
 -- @
 --

XMonad/Actions/Warp.hs

@@ -34,11 +34,11 @@ You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
 
 then add appropriate keybindings to warp the pointer; for example:
 
-> , ((modMask x,   xK_z     ), warpToWindow (1%2) (1%2)) -- @@ Move pointer to currently focused window
+> , ((modm,   xK_z     ), warpToWindow (1%2) (1%2)) -- @@ Move pointer to currently focused window
 >
 >-- mod-ctrl-{w,e,r} @@ Move mouse pointer to screen 1, 2, or 3
 >
->   [((modMask x .|. controlMask, key), warpToScreen sc (1%2) (1%2))
+>   [((modm .|. controlMask, key), warpToScreen sc (1%2) (1%2))
 >       | (key, sc) <- zip [xK_w, xK_e, xK_r] [0..]]
 
 Note that warping to a particular screen may change the focus.

XMonad/Actions/WindowBringer.hs

@@ -38,8 +38,8 @@ import XMonad.Util.NamedWindows (getName)
 --
 -- and define appropriate key bindings:
 --
--- > , ((modMask x .|. shiftMask, xK_g     ), gotoMenu)
+-- > , ((modm .|. shiftMask, xK_g     ), gotoMenu)
--- > , ((modMask x .|. shiftMask, xK_b     ), bringMenu)
+-- > , ((modm .|. shiftMask, xK_b     ), bringMenu)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Actions/WindowGo.hs

@@ -53,8 +53,8 @@ Import the module into your @~\/.xmonad\/xmonad.hs@:
 
 and define appropriate key bindings:
 
-> , ((modMask x .|. shiftMask, xK_g), raise (className =? "Firefox"))
+> , ((modm .|. shiftMask, xK_g), raise (className =? "Firefox"))
-> , ((modMask x .|. shiftMask, xK_b), runOrRaise "firefox" (className =? "Firefox"))
+> , ((modm .|. shiftMask, xK_b), runOrRaise "firefox" (className =? "Firefox"))
 
 (Note that Firefox v3 and up have a class-name of \"Firefox\" and \"Navigator\";
 lower versions use other classnames such as \"Firefox-bin\". Either choose the

XMonad/Actions/WindowMenu.hs

@@ -39,7 +39,7 @@ import XMonad.Util.XUtils (fi)
 --
 -- Then add a keybinding, e.g.
 --
--- >    , ((modMask x,               xK_o ), windowMenu)
+-- >    , ((modm,               xK_o ), windowMenu)
 
 windowMenu :: X ()
 windowMenu = withFocused $ \w -> do

XMonad/Actions/WindowNavigation.hs

@@ -86,15 +86,15 @@ import Graphics.X11.Xlib
 --  - manageHook to draw window decos?
 
 withWindowNavigation :: (KeySym, KeySym, KeySym, KeySym) -> XConfig l -> IO (XConfig l)
-withWindowNavigation (u,l,d,r) conf =
+withWindowNavigation (u,l,d,r) conf@XConfig{modMask=modm} =
-    withWindowNavigationKeys [ ((modMask conf              , u), WNGo   U),
+    withWindowNavigationKeys [ ((modm              , u), WNGo   U),
-                               ((modMask conf              , l), WNGo   L),
+                               ((modm              , l), WNGo   L),
-                               ((modMask conf              , d), WNGo   D),
+                               ((modm              , d), WNGo   D),
-                               ((modMask conf              , r), WNGo   R),
+                               ((modm              , r), WNGo   R),
-                               ((modMask conf .|. shiftMask, u), WNSwap U),
+                               ((modm .|. shiftMask, u), WNSwap U),
-                               ((modMask conf .|. shiftMask, l), WNSwap L),
+                               ((modm .|. shiftMask, l), WNSwap L),
-                               ((modMask conf .|. shiftMask, d), WNSwap D),
+                               ((modm .|. shiftMask, d), WNSwap D),
-                               ((modMask conf .|. shiftMask, r), WNSwap R) ]
+                               ((modm .|. shiftMask, r), WNSwap R) ]
                              conf
 
 withWindowNavigationKeys :: [((KeyMask, KeySym), WNAction)] -> XConfig l -> IO (XConfig l)

XMonad/Actions/WithAll.hs

@@ -30,7 +30,7 @@ import XMonad.StackSet
 --
 -- then add a keybinding; for example:
 --
---     , ((modMask x .|. shiftMask, xK_t), sinkAll)
+--     , ((modm .|. shiftMask, xK_t), sinkAll)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Doc/Extending.hs

@@ -922,8 +922,8 @@ example, you could write:
 and provide an appropriate definition of @myKeys@, such as:
 
 >    myKeys x =
->             [ ((modMask x, xK_F12), xmonadPrompt defaultXPConfig)
+>             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)
->             , ((modMask x, xK_F3 ), shellPrompt  defaultXPConfig)
+>             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig)
 >             ]
 
 This particular definition also requires importing "XMonad.Prompt",
@@ -966,8 +966,8 @@ For instance, if you have defined some additional key bindings like
 these:
 
 >    myKeys x =
->             [ ((modMask x, xK_F12), xmonadPrompt defaultXPConfig)
+>             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)
->             , ((modMask x, xK_F3 ), shellPrompt  defaultXPConfig)
+>             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig)
 >             ]
 
 then you can create a new key bindings map by joining the default one
@@ -999,8 +999,8 @@ All together, your @~\/.xmonad\/xmonad.hs@ would now look like this:
 >    newKeys x = M.union (keys defaultConfig x) (M.fromList (myKeys x))
 >
 >    myKeys x =
->             [ ((modMask x, xK_F12), xmonadPrompt defaultXPConfig)
+>             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)
->             , ((modMask x, xK_F3 ), shellPrompt  defaultXPConfig)
+>             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig)
 >             ]
 
 There are much simpler ways to accomplish this, however, if you are
@@ -1026,8 +1026,8 @@ map and the map of the key bindings you want to remove.  Like so:
 >
 >    keysToRemove :: XConfig Layout ->    [((KeyMask, KeySym),X ())]
 >    keysToRemove x =
->             [ ((modMask x              , xK_q ), return ())
+>             [ ((modm              , xK_q ), return ())
->             , ((modMask x .|. shiftMask, xK_q ), return ())
+>             , ((modm .|. shiftMask, xK_q ), return ())
 >             ]
 
 As you can see, it doesn't matter what actions we associate with the
@@ -1042,8 +1042,8 @@ write something like:
 >
 >    keysToRemove :: XConfig Layout -> [(KeyMask, KeySym)]
 >    keysToRemove x =
->             [ (modMask x              , xK_q )
+>             [ (modm              , xK_q )
->             , (modMask x .|. shiftMask, xK_q )
+>             , (modm .|. shiftMask, xK_q )
 >             ]
 
 Another even simpler possibility is the use of some of the utilities
@@ -1063,23 +1063,23 @@ for removing and adding.  Here is an example from
 >    delKeys x  = foldr M.delete           (defKeys x) (toRemove x)
 >    newKeys x  = foldr (uncurry M.insert) (delKeys x) (toAdd    x)
 >    -- remove some of the default key bindings
->    toRemove x =
+>    toRemove XConfig{modMask = modm} =
->        [ (modMask x              , xK_j     )
+>        [ (modm              , xK_j     )
->        , (modMask x              , xK_k     )
+>        , (modm              , xK_k     )
->        , (modMask x              , xK_p     )
+>        , (modm              , xK_p     )
->        , (modMask x .|. shiftMask, xK_p     )
+>        , (modm .|. shiftMask, xK_p     )
->        , (modMask x .|. shiftMask, xK_q     )
+>        , (modm .|. shiftMask, xK_q     )
->        , (modMask x              , xK_q     )
+>        , (modm              , xK_q     )
 >        ] ++
->        -- I want modMask .|. shiftMask 1-9 to be free!
+>        -- I want modm .|. shiftMask 1-9 to be free!
->        [(shiftMask .|. modMask x, k) | k <- [xK_1 .. xK_9]]
+>        [(shiftMask .|. modm, k) | k <- [xK_1 .. xK_9]]
 >    -- These are my personal key bindings
->    toAdd x   =
+>    toAdd XConfig{modMask = modm} =
->        [ ((modMask x              , xK_F12   ), xmonadPrompt defaultXPConfig )
+>        [ ((modm              , xK_F12   ), xmonadPrompt defaultXPConfig )
->        , ((modMask x              , xK_F3    ), shellPrompt  defaultXPConfig )
+>        , ((modm              , xK_F3    ), shellPrompt  defaultXPConfig )
 >        ] ++
->        -- Use modMask .|. shiftMask .|. controlMask 1-9 instead
+>        -- Use modm .|. shiftMask .|. controlMask 1-9 instead
->        [( (m .|. modMask x, k), windows $ f i)
+>        [( (m .|. modm, k), windows $ f i)
 >         | (i, k) <- zip (workspaces x) [xK_1 .. xK_9]
 >        ,  (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask .|. controlMask)]
 >        ]
@@ -1088,6 +1088,8 @@ You can achieve the same result using the "XMonad.Util.CustomKeys"
 module; take a look at the 'XMonad.Util.CustomKeys.customKeys'
 function in particular.
 
+NOTE: modm is defined as the modMask you defined (or left as the default) in
+your config.
 -}
 
 {- $mouse

XMonad/Hooks/DynamicHooks.hs

@@ -54,12 +54,12 @@ import Data.IORef
 -- module:
 --
 -- > xmonad { keys = myKeys `Data.Map.union` Data.Map.fromList
--- >                   [((modMask conf, xK_i), oneShotHook dynHooksRef
+-- >                   [((modm, xK_i), oneShotHook dynHooksRef
 -- >                    "FFlaunchHook" (className =? "firefox") (doShift "3")
 -- >                    >> spawn "firefox")
--- >                   ,((modMask conf, xK_u), addDynamicHook dynHooksRef
+-- >                   ,((modm, xK_u), addDynamicHook dynHooksRef
 -- >                     (className =? "example" --> doFloat))
--- >                   ,((modMask conf, xK_y), updatePermanentHook dynHooksRef
+-- >                   ,((modm, xK_y), updatePermanentHook dynHooksRef
 -- >                     (const idHook))) ]  -- resets the permanent hook.
 --
 

XMonad/Hooks/FloatNext.hs

@@ -86,12 +86,12 @@ floatModeMVar = unsafePerformIO $ newMVar (False, False)
 -- The 'floatNext' and 'toggleFloatNext' functions can be used in key
 -- bindings to float the next spawned window:
 --
--- > , ((modMask, xK_e), toggleFloatNext)
+-- > , ((modm, xK_e), toggleFloatNext)
 --
 -- 'floatAllNew' and 'toggleFloatAllNew' are similar but float all
 -- spawned windows until disabled again.
 --
--- > , ((modMask, xK_r), toggleFloatAllNew)
+-- > , ((modm, xK_r), toggleFloatAllNew)
 
 
 -- | This 'ManageHook' will selectively float windows as set
@@ -140,7 +140,7 @@ willFloatAllNew = _get snd
 -- that the effects of a 'floatNext'/... will be visible
 -- immediately:
 --
--- > , ((modMask, xK_e), toggleFloatNext >> runLogHook)
+-- > , ((modm, xK_e), toggleFloatNext >> runLogHook)
 --
 -- The @String -> String@ parameters to 'willFloatNextPP' and
 -- 'willFloatAllNewPP' will be applied to their output, you

XMonad/Hooks/ManageDocks.hs

@@ -59,12 +59,12 @@ import qualified Data.Set as S
 -- 'AvoidStruts' also supports toggling the dock gaps; add a keybinding
 -- similar to:
 --
--- > ,((modMask x, xK_b     ), sendMessage ToggleStruts)
+-- > ,((modm, xK_b     ), sendMessage ToggleStruts)
 --
 -- If you have multiple docks, you can toggle their gaps individually.
 -- For example, to toggle only the top gap:
 --
--- > ,((modMask x .|. controlMask, xK_t), sendMessage $ ToggleStrut U)
+-- > ,((modm .|. controlMask, xK_t), sendMessage $ ToggleStrut U)
 --
 -- Similarly, you can use 'D', 'L', and 'R' to individually toggle
 -- gaps on the bottom, left, or right.
@@ -165,19 +165,19 @@ instance Message ToggleStruts
 --
 -- Show all gaps:
 --
--- >   ,((modMask x .|. shiftMask  ,xK_b),sendMessage $ SetStruts [minBound .. maxBound] [])
+-- >   ,((modm .|. shiftMask  ,xK_b),sendMessage $ SetStruts [minBound .. maxBound] [])
 --
 -- Hide all gaps:
 --
--- >   ,((modMask x .|. controlMask,xK_b),sendMessage $ SetStruts [] [minBound .. maxBound])
+-- >   ,((modm .|. controlMask,xK_b),sendMessage $ SetStruts [] [minBound .. maxBound])
 --
 -- Show only upper and left gaps:
 --
--- >   ,((modMask x .|. controlMask .|. shiftMask,xK_b),sendMessage $ SetStruts [U,L] [minBound .. maxBound])
+-- >   ,((modm .|. controlMask .|. shiftMask,xK_b),sendMessage $ SetStruts [U,L] [minBound .. maxBound])
 --
 -- Hide the bottom keeping whatever the other values were:
 --
--- >   ,((modMask x .|. controlMask .|. shiftMask,xK_g),sendMessage $ SetStruts [] [D])
+-- >   ,((modm .|. controlMask .|. shiftMask,xK_g),sendMessage $ SetStruts [] [D])
 data SetStruts = SetStruts { addedStruts   :: [Direction2D]
                            , removedStruts :: [Direction2D] -- ^ These are removed from the currently set struts before 'addedStruts' are added.
                            }

XMonad/Hooks/Place.hs

@@ -68,7 +68,7 @@ import Control.Monad.Trans (lift)
 -- You can also define a key to manually trigger repositioning with 'placeFocused' by
 -- adding the following to your keys definition:
 --
--- > , ((modMask, xK_w), placeFocused simpleSmart)
+-- > , ((modm, xK_w), placeFocused simpleSmart)
 --
 -- Both 'placeHook' and 'placeFocused' take a 'Placement' parameter, which specifies
 -- the placement policy to use (smart, under the mouse, fixed position, etc.). See

XMonad/Hooks/UrgencyHook.hs

@@ -251,14 +251,14 @@ urgencyConfig = UrgencyConfig { suppressWhen = Visible, remindWhen = Dont }
 -- | Focuses the most recently urgent window. Good for what ails ya -- I mean, your keybindings.
 -- Example keybinding:
 --
--- > , ((modMask              , xK_BackSpace), focusUrgent)
+-- > , ((modm              , xK_BackSpace), focusUrgent)
 focusUrgent :: X ()
 focusUrgent = withUrgents $ flip whenJust (windows . W.focusWindow) . listToMaybe
 
 -- | Just makes the urgents go away.
 -- Example keybinding:
 --
--- > , ((modMask .|. shiftMask, xK_BackSpace), clearUrgents)
+-- > , ((modm .|. shiftMask, xK_BackSpace), clearUrgents)
 clearUrgents :: X ()
 clearUrgents = adjustUrgents (const []) >> adjustReminders (const [])
 

XMonad/Layout/BoringWindows.hs

@@ -51,9 +51,9 @@ import qualified XMonad.StackSet as W
 --
 -- Then to your keybindings, add:
 --
--- > , ((modMask, xK_j), focusUp)
+-- > , ((modm, xK_j), focusUp)
--- > , ((modMask, xK_k), focusDown)
+-- > , ((modm, xK_k), focusDown)
--- > , ((modMask, xK_m), focusMaster)
+-- > , ((modm, xK_m), focusMaster)
 --
 -- For more detailed instructions on editing the layoutHook see:
 --

XMonad/Layout/Combo.hs

@@ -51,10 +51,10 @@ import qualified XMonad.StackSet as W ( differentiate )
 -- each sublayout. To do this, use "XMonad.Layout.WindowNavigation",
 -- and add the following key bindings (or something similar):
 --
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_Right), sendMessage $ Move R)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_Right), sendMessage $ Move R)
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_Left ), sendMessage $ Move L)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_Left ), sendMessage $ Move L)
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_Up   ), sendMessage $ Move U)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_Up   ), sendMessage $ Move U)
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_Down ), sendMessage $ Move D)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_Down ), sendMessage $ Move D)
 --
 -- For detailed instruction on editing the key binding see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Layout/ComboP.hs

@@ -57,11 +57,11 @@ import qualified XMonad.StackSet as W
 -- To use it, import \"XMonad.Layout.WindowNavigation\", and add the following key
 -- bindings (or something similar):
 --
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_Right), sendMessage $ Move R)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_Right), sendMessage $ Move R)
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_Left ), sendMessage $ Move L)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_Left ), sendMessage $ Move L)
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_Up   ), sendMessage $ Move U)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_Up   ), sendMessage $ Move U)
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_Down ), sendMessage $ Move D)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_Down ), sendMessage $ Move D)
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_s    ), sendMessage $ SwapWindow)
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_s    ), sendMessage $ SwapWindow)
 --
 -- For detailed instruction on editing the key binding see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Layout/Gaps.hs

@@ -54,10 +54,10 @@ import Data.List (delete)
 -- You can additionally add some keybindings to toggle or modify the gaps,
 -- for example:
 --
--- > , ((modMask x .|. controlMask, xK_g), sendMessage $ ToggleGaps)  -- toggle all gaps
+-- > , ((modm .|. controlMask, xK_g), sendMessage $ ToggleGaps)  -- toggle all gaps
--- > , ((modMask x .|. controlMask, xK_t), sendMessage $ ToggleGap U) -- toggle the top gap
+-- > , ((modm .|. controlMask, xK_t), sendMessage $ ToggleGap U) -- toggle the top gap
--- > , ((modMask x .|. controlMask, xK_w), sendMessage $ IncGap R 5)  -- increment the right-hand gap
+-- > , ((modm .|. controlMask, xK_w), sendMessage $ IncGap R 5)  -- increment the right-hand gap
--- > , ((modMask x .|. controlMask, xK_q), sendMessage $ DecGap R 5)  -- decrement the right-hand gap
+-- > , ((modm .|. controlMask, xK_q), sendMessage $ DecGap R 5)  -- decrement the right-hand gap
 --
 -- If you want complete control over all gaps, you could include
 -- something like this in your keybindings, assuming in this case you

XMonad/Layout/GridVariants.hs

@@ -51,10 +51,10 @@ import qualified XMonad.StackSet as W
 -- To be able to change the geometry of the master grid, add something
 -- like this to your keybindings:
 --
--- > ((modMask .|. shiftMask, xK_equal), sendMessage $ IncMasterCols 1),
+-- > ((modm .|. shiftMask, xK_equal), sendMessage $ IncMasterCols 1),
--- > ((modMask .|. shiftMask, xK_minus), sendMessage $ IncMasterCols (-1)),
+-- > ((modm .|. shiftMask, xK_minus), sendMessage $ IncMasterCols (-1)),
--- > ((modMask .|. ctrlMask,  xK_equal), sendMessage $ IncMasterRows 1),
+-- > ((modm .|. controlMask,  xK_equal), sendMessage $ IncMasterRows 1),
--- > ((modMask .|. ctrlMask,  xK_minus), sendMessage $ IncMasterRows (-1))
+-- > ((modm .|. controlMask,  xK_minus), sendMessage $ IncMasterRows (-1))
 
 -- | Grid layout.  The parameter is the desired x:y aspect ratio of windows
 data Grid a = Grid !Rational

XMonad/Layout/IndependentScreens.hs

@@ -48,13 +48,13 @@ import XMonad.StackSet hiding (workspaces)
 -- to specific workspace names.  In the default configuration, only
 -- the keybindings for changing workspace do this:
 --
--- > [((m .|. modMask, k), windows $ f i)
+-- > [((m .|. modm, k), windows $ f i)
 -- >     | (i, k) <- zip (XMonad.workspaces conf) [xK_1 .. xK_9]
 -- >     , (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)]]
 --
 -- This should change to
 --
--- > [((m .|. modMask, k), windows $ onCurrentScreen f i)
+-- > [((m .|. modm, k), windows $ onCurrentScreen f i)
 -- >     | (i, k) <- zip (workspaces' conf) [xK_1 .. xK_9]
 -- >     , (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)]]
 --

XMonad/Layout/LayoutBuilder.hs

@@ -70,8 +70,8 @@ import Control.Monad
 --
 -- You may wish to add the following keybindings:
 --
--- >    , ((modMask x .|. shiftMask, xK_h ), sendMessage $ IncLayoutN (-1))
+-- >    , ((modm .|. shiftMask, xK_h ), sendMessage $ IncLayoutN (-1))
--- >    , ((modMask x .|. shiftMask, xK_l ), sendMessage $ IncLayoutN 1)
+-- >    , ((modm .|. shiftMask, xK_l ), sendMessage $ IncLayoutN 1)
 --
 -- For detailed instruction on editing the key binding see:
 --

XMonad/Layout/LayoutCombinators.hs

@@ -78,7 +78,7 @@ import XMonad.Layout.DragPane
 --
 -- Then bind some keys to a 'JumpToLayout' message:
 --
--- >   , ((modMask x .|. controlMask, xK_f), sendMessage $ JumpToLayout "Full")  -- jump directly to the Full layout
+-- >   , ((modm .|. controlMask, xK_f), sendMessage $ JumpToLayout "Full")  -- jump directly to the Full layout
 --
 -- See below for more detailed documentation.
 

XMonad/Layout/LayoutScreens.hs

@@ -39,8 +39,8 @@ import qualified XMonad.StackSet as W
 --
 -- Then add some keybindings; for example:
 --
--- >   , ((modMask x .|. shiftMask,                 xK_space), layoutScreens 2 (TwoPane 0.5 0.5))
+-- >   , ((modm .|. shiftMask,                 xK_space), layoutScreens 2 (TwoPane 0.5 0.5))
--- >   , ((modMask x .|. controlMask .|. shiftMask, xK_space), rescreen)
+-- >   , ((modm .|. controlMask .|. shiftMask, xK_space), rescreen)
 --
 -- Another example use would be to handle a scenario where xrandr didn't
 -- work properly (e.g. a VNC X server in my case) and you want to be able
@@ -48,9 +48,9 @@ import qualified XMonad.StackSet as W
 --
 -- > import XMonad.Layout.LayoutScreens
 --
--- >   , ((modMask x .|. shiftMask, xK_space),
+-- >   , ((modm .|. shiftMask, xK_space),
 -- >        layoutScreens 1 (fixedLayout [Rectangle 0 0 1024 768]))
--- >   , ((modMask x .|. controlMask .|. shiftMask, xK_space), rescreen)
+-- >   , ((modm .|. controlMask .|. shiftMask, xK_space), rescreen)
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Layout/Magnifier.hs

@@ -59,11 +59,11 @@ import XMonad.Layout.LayoutModifier
 -- Magnifier supports some commands. To use them add something like
 -- this to your key bindings:
 --
--- >    , ((modMask x .|. controlMask              , xK_plus ), sendMessage MagnifyMore)
+-- >    , ((modm .|. controlMask              , xK_plus ), sendMessage MagnifyMore)
--- >    , ((modMask x .|. controlMask              , xK_minus), sendMessage MagnifyLess)
+-- >    , ((modm .|. controlMask              , xK_minus), sendMessage MagnifyLess)
--- >    , ((modMask x .|. controlMask              , xK_o    ), sendMessage ToggleOff  )
+-- >    , ((modm .|. controlMask              , xK_o    ), sendMessage ToggleOff  )
--- >    , ((modMask x .|. controlMask .|. shiftMask, xK_o    ), sendMessage ToggleOn   )
+-- >    , ((modm .|. controlMask .|. shiftMask, xK_o    ), sendMessage ToggleOn   )
--- >    , ((modMask x .|. controlMask              , xK_m    ), sendMessage Toggle     )
+-- >    , ((modm .|. controlMask              , xK_m    ), sendMessage Toggle     )
 --
 -- Note that a few other extension modules, such as
 -- "XMonad.Layout.MultiToggle" and "XMonad.Layout.ToggleLayouts", also

XMonad/Layout/Maximize.hs

@@ -43,7 +43,7 @@ import Data.List ( partition )
 --
 -- In the key-bindings, do something like:
 --
--- >        , ((modMask x, xK_backslash), withFocused (sendMessage . maximizeRestore))
+-- >        , ((modm, xK_backslash), withFocused (sendMessage . maximizeRestore))
 -- >        ...
 --
 -- For detailed instruction on editing the key binding see:

XMonad/Layout/MessageControl.hs

@@ -54,7 +54,7 @@ import Control.Arrow (second)
 --  @sendMessage $ escape message@, e.g.
 --
 -- > -- Change the inner layout
--- > ((modMask .|. controlMask, xK_space), sendMessage $ escape NextLayout)
+-- > ((modm .|. controlMask, xK_space), sendMessage $ escape NextLayout)
 --
 -- If you want unescaped messages to be handled /only/ by the enclosing
 -- layout, use the 'ignore' modifier:

XMonad/Layout/Minimize.hs

@@ -43,8 +43,8 @@ import Data.List
 --
 -- In the key-bindings, do something like:
 --
--- >        , ((modMask',               xK_m     ), withFocused (\f -> sendMessage (MinimizeWin f)))
+-- >        , ((modm,               xK_m     ), withFocused (\f -> sendMessage (MinimizeWin f)))
--- >        , ((modMask' .|. shiftMask, xK_m     ), sendMessage RestoreNextMinimizedWin)
+-- >        , ((modm .|. shiftMask, xK_m     ), sendMessage RestoreNextMinimizedWin)
 --
 -- The first action will minimize the focused window, while the second one will restore
 -- the next minimized window.

XMonad/Layout/Mosaic.hs

@@ -56,10 +56,10 @@ import Data.Monoid(Monoid,mempty, mappend)
 -- To change the choice in aspect ratio and the relative sizes of windows, add
 -- to your keybindings:
 --
---  > , ((modMask, xK_a), sendMessage Taller)
+--  > , ((modm, xK_a), sendMessage Taller)
---  > , ((modMask, xK_z), sendMessage Wider)
+--  > , ((modm, xK_z), sendMessage Wider)
 --
---  > , ((modMask, xK_r), sendMessage Reset)
+--  > , ((modm, xK_r), sendMessage Reset)
 --
 -- For more detailed instructions on editing the layoutHook see:
 --

XMonad/Layout/MosaicAlt.hs

@@ -50,11 +50,11 @@ import Data.Ratio
 --
 -- In the key-bindings, do something like:
 --
--- >     , ((modMask x .|. shiftMask  , xK_a    ), withFocused (sendMessage . expandWindowAlt))
+-- >     , ((modm .|. shiftMask  , xK_a    ), withFocused (sendMessage . expandWindowAlt))
--- >     , ((modMask x .|. shiftMask  , xK_z    ), withFocused (sendMessage . shrinkWindowAlt))
+-- >     , ((modm .|. shiftMask  , xK_z    ), withFocused (sendMessage . shrinkWindowAlt))
--- >     , ((modMask x .|. shiftMask  , xK_s    ), withFocused (sendMessage . tallWindowAlt))
+-- >     , ((modm .|. shiftMask  , xK_s    ), withFocused (sendMessage . tallWindowAlt))
--- >     , ((modMask x .|. shiftMask  , xK_d    ), withFocused (sendMessage . wideWindowAlt))
+-- >     , ((modm .|. shiftMask  , xK_d    ), withFocused (sendMessage . wideWindowAlt))
--- >     , ((modMask x .|. controlMask, xK_space), sendMessage resetAlt)
+-- >     , ((modm .|. controlMask, xK_space), sendMessage resetAlt)
 -- >     ...
 --
 -- For detailed instruction on editing the key binding see:

XMonad/Layout/MouseResizableTile.hs

@@ -49,8 +49,8 @@ import XMonad.Util.XUtils
 --
 -- You may also want to add the following key bindings:
 --
--- > , ((modMask x,               xK_u), sendMessage ShrinkSlave) -- %! Shrink a slave area
+-- > , ((modm,               xK_u), sendMessage ShrinkSlave) -- %! Shrink a slave area
--- > , ((modMask x,               xK_i), sendMessage ExpandSlave) -- %! Expand a slave area
+-- > , ((modm,               xK_i), sendMessage ExpandSlave) -- %! Expand a slave area
 --
 -- For detailed instruction on editing the key binding see:
 --

XMonad/Layout/MultiToggle.hs

@@ -63,7 +63,7 @@ import Data.Maybe
 -- you can now dynamically apply the 'XMonad.Layout.Mirror' transformation:
 --
 -- > ...
--- >   , ((modMask,               xK_x     ), sendMessage $ Toggle MIRROR)
+-- >   , ((modm,               xK_x     ), sendMessage $ Toggle MIRROR)
 -- > ...
 --
 -- (That should be part of your key bindings.) When you press @mod-x@, the

XMonad/Layout/Reflect.hs

@@ -58,8 +58,8 @@ import XMonad.Layout.MultiToggle
 --
 -- Finally, add some keybindings to do the toggling, for example:
 --
--- > , ((modMask x .|. controlMask, xK_x), sendMessage $ Toggle REFLECTX)
+-- > , ((modm .|. controlMask, xK_x), sendMessage $ Toggle REFLECTX)
--- > , ((modMask x .|. controlMask, xK_y), sendMessage $ Toggle REFLECTY)
+-- > , ((modm .|. controlMask, xK_y), sendMessage $ Toggle REFLECTY)
 --
 
 -- | Apply a horizontal reflection (left \<--\> right) to a

XMonad/Layout/ResizableTile.hs

@@ -42,8 +42,8 @@ import Data.List ((\\))
 --
 -- You may also want to add the following key bindings:
 --
--- > , ((modMask x,               xK_a), sendMessage MirrorShrink)
+-- > , ((modm,               xK_a), sendMessage MirrorShrink)
--- > , ((modMask x,               xK_z), sendMessage MirrorExpand)
+-- > , ((modm,               xK_z), sendMessage MirrorExpand)
 --
 -- For detailed instruction on editing the key binding see:
 --

XMonad/Layout/ToggleLayouts.hs

@@ -38,11 +38,11 @@ import XMonad.StackSet (Workspace (..))
 --
 -- To toggle between layouts add a key binding like
 --
--- >    , ((modMask x .|. controlMask, xK_space), sendMessage ToggleLayout)
+-- >    , ((modm .|. controlMask, xK_space), sendMessage ToggleLayout)
 --
 -- or a key binding like
 --
--- >    , ((modMask x .|. controlMask, xK_space), sendMessage (Toggle "Full"))
+-- >    , ((modm .|. controlMask, xK_space), sendMessage (Toggle "Full"))
 --
 -- For detailed instruction on editing the key binding see:
 --

XMonad/Layout/WindowArranger.hs

@@ -53,20 +53,20 @@ import Data.Maybe
 -- You may also want to define some key binding to move or resize
 -- windows. These are good defaults:
 --
--- >        , ((modMask x .|. controlMask              , xK_s    ), sendMessage  Arrange         )
+-- >        , ((modm .|. controlMask              , xK_s    ), sendMessage  Arrange         )
--- >        , ((modMask x .|. controlMask .|. shiftMask, xK_s    ), sendMessage  DeArrange       )
+-- >        , ((modm .|. controlMask .|. shiftMask, xK_s    ), sendMessage  DeArrange       )
--- >        , ((modMask x .|. controlMask              , xK_Left ), sendMessage (MoveLeft      1))
+-- >        , ((modm .|. controlMask              , xK_Left ), sendMessage (MoveLeft      1))
--- >        , ((modMask x .|. controlMask              , xK_Right), sendMessage (MoveRight     1))
+-- >        , ((modm .|. controlMask              , xK_Right), sendMessage (MoveRight     1))
--- >        , ((modMask x .|. controlMask              , xK_Down ), sendMessage (MoveDown      1))
+-- >        , ((modm .|. controlMask              , xK_Down ), sendMessage (MoveDown      1))
--- >        , ((modMask x .|. controlMask              , xK_Up   ), sendMessage (MoveUp        1))
+-- >        , ((modm .|. controlMask              , xK_Up   ), sendMessage (MoveUp        1))
--- >        , ((modMask x                 .|. shiftMask, xK_Left ), sendMessage (IncreaseLeft  1))
+-- >        , ((modm                 .|. shiftMask, xK_Left ), sendMessage (IncreaseLeft  1))
--- >        , ((modMask x                 .|. shiftMask, xK_Right), sendMessage (IncreaseRight 1))
+-- >        , ((modm                 .|. shiftMask, xK_Right), sendMessage (IncreaseRight 1))
--- >        , ((modMask x                 .|. shiftMask, xK_Down ), sendMessage (IncreaseDown  1))
+-- >        , ((modm                 .|. shiftMask, xK_Down ), sendMessage (IncreaseDown  1))
--- >        , ((modMask x                 .|. shiftMask, xK_Up   ), sendMessage (IncreaseUp    1))
+-- >        , ((modm                 .|. shiftMask, xK_Up   ), sendMessage (IncreaseUp    1))
--- >        , ((modMask x .|. controlMask .|. shiftMask, xK_Left ), sendMessage (DecreaseLeft  1))
+-- >        , ((modm .|. controlMask .|. shiftMask, xK_Left ), sendMessage (DecreaseLeft  1))
--- >        , ((modMask x .|. controlMask .|. shiftMask, xK_Right), sendMessage (DecreaseRight 1))
+-- >        , ((modm .|. controlMask .|. shiftMask, xK_Right), sendMessage (DecreaseRight 1))
--- >        , ((modMask x .|. controlMask .|. shiftMask, xK_Down ), sendMessage (DecreaseDown  1))
+-- >        , ((modm .|. controlMask .|. shiftMask, xK_Down ), sendMessage (DecreaseDown  1))
--- >        , ((modMask x .|. controlMask .|. shiftMask, xK_Up   ), sendMessage (DecreaseUp    1))
+-- >        , ((modm .|. controlMask .|. shiftMask, xK_Up   ), sendMessage (DecreaseUp    1))
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Layout/WindowNavigation.hs

@@ -49,14 +49,14 @@ import XMonad.Util.XUtils
 --
 -- In keybindings:
 --
--- >    , ((modMask x,                 xK_Right), sendMessage $ Go R)
+-- >    , ((modm,                 xK_Right), sendMessage $ Go R)
--- >    , ((modMask x,                 xK_Left ), sendMessage $ Go L)
+-- >    , ((modm,                 xK_Left ), sendMessage $ Go L)
--- >    , ((modMask x,                 xK_Up   ), sendMessage $ Go U)
+-- >    , ((modm,                 xK_Up   ), sendMessage $ Go U)
--- >    , ((modMask x,                 xK_Down ), sendMessage $ Go D)
+-- >    , ((modm,                 xK_Down ), sendMessage $ Go D)
--- >    , ((modMask x .|. controlMask, xK_Right), sendMessage $ Swap R)
+-- >    , ((modm .|. controlMask, xK_Right), sendMessage $ Swap R)
--- >    , ((modMask x .|. controlMask, xK_Left ), sendMessage $ Swap L)
+-- >    , ((modm .|. controlMask, xK_Left ), sendMessage $ Swap L)
--- >    , ((modMask x .|. controlMask, xK_Up   ), sendMessage $ Swap U)
+-- >    , ((modm .|. controlMask, xK_Up   ), sendMessage $ Swap U)
--- >    , ((modMask x .|. controlMask, xK_Down ), sendMessage $ Swap D)
+-- >    , ((modm .|. controlMask, xK_Down ), sendMessage $ Swap D)
 --
 -- For detailed instruction on editing the key binding see:
 --

XMonad/Layout/WorkspaceDir.hs

@@ -56,7 +56,7 @@ import XMonad.StackSet ( tag, currentTag )
 -- WorkspaceDir provides also a prompt. To use it you need to import
 -- "XMonad.Prompt" and add something like this to your key bindings:
 --
--- >  , ((modMask x .|. shiftMask, xK_x     ), changeDir defaultXPConfig)
+-- >  , ((modm .|. shiftMask, xK_x     ), changeDir defaultXPConfig)
 --
 -- For detailed instruction on editing the key binding see:
 --

XMonad/Prompt/AppendFile.hs

@@ -41,7 +41,7 @@ import Control.Exception
 --
 -- and adding an appropriate keybinding, for example:
 --
--- >  , ((modMask x .|. controlMask, xK_n), appendFilePrompt defaultXPConfig "/home/me/NOTES")
+-- >  , ((modm .|. controlMask, xK_n), appendFilePrompt defaultXPConfig "/home/me/NOTES")
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Prompt/Email.hs

@@ -36,7 +36,7 @@ import XMonad.Prompt.Input
 --
 -- and adding an appropriate keybinding, for example:
 --
--- >  , ((modMask x .|. controlMask, xK_e), emailPrompt defaultXPConfig addresses)
+-- >  , ((modm .|. controlMask, xK_e), emailPrompt defaultXPConfig addresses)
 --
 -- where @addresses@ is a list of email addresses that should
 -- autocomplete, for example:

XMonad/Prompt/Input.hs

@@ -59,7 +59,7 @@ import XMonad.Prompt
 -- Now all he has to do is add a keybinding to @firingPrompt@ (or
 -- @firingPrompt'@), such as
 --
--- >  , ((modMask x .|. controlMask, xK_f),  firingPrompt)
+-- >  , ((modm .|. controlMask, xK_f),  firingPrompt)
 --
 -- Now when Mr. Big hits mod-ctrl-f, a prompt will pop up saying
 -- \"Fire: \", waiting for him to type the name of someone to fire.

XMonad/Prompt/Layout.hs

@@ -30,7 +30,7 @@ import XMonad.Layout.LayoutCombinators ( JumpToLayout(..) )
 -- > import XMonad.Prompt
 -- > import XMonad.Prompt.Layout
 --
--- >   , ((modMask x .|. shiftMask, xK_m     ), layoutPrompt defaultXPConfig)
+-- >   , ((modm .|. shiftMask, xK_m     ), layoutPrompt defaultXPConfig)
 --
 -- For detailed instruction on editing the key binding see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Prompt/Man.hs

@@ -44,7 +44,7 @@ import Data.Maybe
 --
 -- 2. In your keybindings add something like:
 --
--- >     , ((modMask x, xK_F1), manPrompt defaultXPConfig)
+-- >     , ((modm, xK_F1), manPrompt defaultXPConfig)
 --
 -- For detailed instruction on editing the key binding see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Prompt/RunOrRaise.hs

@@ -37,7 +37,7 @@ import System.Directory (doesDirectoryExist, doesFileExist, executable, getPermi
 
 2. In your keybindings add something like:
 
->   , ((modMask x .|. controlMask, xK_x), runOrRaisePrompt defaultXPConfig)
+>   , ((modm .|. controlMask, xK_x), runOrRaisePrompt defaultXPConfig)
 
 For detailed instruction on editing the key binding see
 "XMonad.Doc.Extending#Editing_key_bindings". -}

XMonad/Prompt/Shell.hs

@@ -44,7 +44,7 @@ import XMonad.Prompt
 --
 -- 2. In your keybindings add something like:
 --
--- >   , ((modMask x .|. controlMask, xK_x), shellPrompt defaultXPConfig)
+-- >   , ((modm .|. controlMask, xK_x), shellPrompt defaultXPConfig)
 --
 -- For detailed instruction on editing the key binding see
 -- "XMonad.Doc.Extending#Editing_key_bindings".
@@ -67,8 +67,8 @@ shellPrompt c = do
 -- is the program to be run with the interactive input.
 -- You would use these like this:
 --
--- >     , ((modMask,               xK_b), safePrompt "firefox" greenXPConfig)
+-- >     , ((modm,               xK_b), safePrompt "firefox" greenXPConfig)
--- >     , ((modMask .|. shiftMask, xK_c), prompt ("xterm" ++ " -e") greenXPConfig)
+-- >     , ((modm .|. shiftMask, xK_c), prompt ("xterm" ++ " -e") greenXPConfig)
 --
 -- Note that you want to use safePrompt for Firefox input, as Firefox
 -- wants URLs, and unsafePrompt for the XTerm example because this allows

XMonad/Prompt/Ssh.hs

@@ -37,7 +37,7 @@ import Data.Maybe
 --
 -- 2. In your keybindings add something like:
 --
--- >   , ((modMask x .|. controlMask, xK_s), sshPrompt defaultXPConfig)
+-- >   , ((modm .|. controlMask, xK_s), sshPrompt defaultXPConfig)
 --
 -- Keep in mind, that if you want to use the completion you have to
 -- disable the "HashKnownHosts" option in your ssh_config

XMonad/Prompt/Theme.hs

@@ -35,7 +35,7 @@ import XMonad.Util.Themes
 --
 -- in your keybindings add:
 --
--- >   , ((modMask x .|. controlMask, xK_t), themePrompt defaultXPConfig)
+-- >   , ((modm .|. controlMask, xK_t), themePrompt defaultXPConfig)
 --
 -- For detailed instruction on editing the key binding see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Prompt/Window.hs

@@ -44,12 +44,12 @@ import XMonad.Actions.WindowBringer
 --
 -- and in the keys definition:
 --
--- > , ((modMask x .|. shiftMask, xK_g     ), windowPromptGoto  defaultXPConfig)
+-- > , ((modm .|. shiftMask, xK_g     ), windowPromptGoto  defaultXPConfig)
--- > , ((modMask x .|. shiftMask, xK_b     ), windowPromptBring defaultXPConfig)
+-- > , ((modm .|. shiftMask, xK_b     ), windowPromptBring defaultXPConfig)
 --
 -- The autoComplete option is a handy complement here:
 --
--- > , ((modMask x .|. shiftMask, xK_g     ), windowPromptGoto
+-- > , ((modm .|. shiftMask, xK_g     ), windowPromptGoto
 -- >                                            defaultXPConfig { autoComplete = Just 500000 } )
 --
 -- The \'500000\' is the number of microseconds to pause before sending you to

XMonad/Prompt/Workspace.hs

@@ -29,7 +29,7 @@ import XMonad.Util.WorkspaceCompare ( getSortByIndex )
 -- > import XMonad.Prompt
 -- > import XMonad.Prompt.Workspace
 --
--- >   , ((modMask x .|. shiftMask, xK_m     ), workspacePrompt defaultXPConfig (windows . W.shift))
+-- >   , ((modm .|. shiftMask, xK_m     ), workspacePrompt defaultXPConfig (windows . W.shift))
 --
 -- For detailed instruction on editing the key binding see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Prompt/XMonad.hs

@@ -32,7 +32,7 @@ import Data.Maybe (fromMaybe)
 --
 -- in your keybindings add:
 --
--- >   , ((modMask x .|. controlMask, xK_x), xmonadPrompt defaultXPConfig)
+-- >   , ((modm .|. controlMask, xK_x), xmonadPrompt defaultXPConfig)
 --
 -- For detailed instruction on editing the key binding see
 -- "XMonad.Doc.Extending#Editing_key_bindings".

XMonad/Util/NamedScratchpad.hs

@@ -72,9 +72,9 @@ import qualified XMonad.StackSet as W
 --
 -- Add keybindings:
 --
--- >  , ((modMask x .|. controlMask .|. shiftMask, xK_t), namedScratchpadAction scratchpads "htop")
+-- >  , ((modm .|. controlMask .|. shiftMask, xK_t), namedScratchpadAction scratchpads "htop")
--- >  , ((modMask x .|. controlMask .|. shiftMask, xK_s), namedScratchpadAction scratchpads "stardict")
+-- >  , ((modm .|. controlMask .|. shiftMask, xK_s), namedScratchpadAction scratchpads "stardict")
--- >  , ((modMask x .|. controlMask .|. shiftMask, xK_n), namedScratchpadAction scratchpads "notes")
+-- >  , ((modm .|. controlMask .|. shiftMask, xK_n), namedScratchpadAction scratchpads "notes")
 --
 -- ... and a manage hook:
 --

XMonad/Util/Run.hs

@@ -100,8 +100,8 @@ unsafeSpawn is internally an alias for XMonad's 'spawn', to remind one that use
 of it can be, well, unsafe.
 Examples:
 
-> , ((modMask, xK_Print), unsafeSpawn "import -window root $HOME/xwd-$(date +%s)$$.png")
+> , ((modm, xK_Print), unsafeSpawn "import -window root $HOME/xwd-$(date +%s)$$.png")
-> , ((modMask, xK_d    ), safeSpawn "firefox" "")
+> , ((modm, xK_d    ), safeSpawn "firefox" "")
 
 Note that the unsafeSpawn example must be unsafe and not safe because
 it makes use of shell interpretation by relying on @$HOME@ and

XMonad/Util/XSelection.hs

@@ -40,7 +40,7 @@ import Codec.Binary.UTF8.String (decode)
    the selection string is an URL you just highlighted), then one could add
    to the xmonad.hs a line like thus:
 
-   > , ((modMask .|. shiftMask, xK_b), promptSelection "firefox")
+   > , ((modm .|. shiftMask, xK_b), promptSelection "firefox")
 
    There are a number of known problems with XSelection: