prop_double_swap (ss :: T) (t1 :: NonNegative Int)
  (t2 :: NonNegative Int) = ...

propDoubleSwap (ss :: T) (t1 :: NonNegative Int)
  (t2 :: NonNegative Int) = ...

prop_invalid_swap (ss :: T) (t1 :: NonNegative Int)
  (t2 :: NonNegative Int) = ...

propInvalidSwap (ss :: T) (t1 :: NonNegative Int)
  (t2 :: NonNegative Int) = ...

prop_swap_only_two (ss :: T) (t1 :: NonNegative Int)
  (t2 :: NonNegative Int) = ...

propSwapOnlyTwo (ss :: T) (t1 :: NonNegative Int)
  (t2 :: NonNegative Int) = ...

prop_swap_with_current (ss :: T) (t :: NonNegative Int) = ...

propSwapWithCurrent (ss :: T) (t :: NonNegative Int) = ...

doubleCheck p = check (defaultConfig{configMaxTest = 1000}) p

doubleCheck = check (defaultConfig{configMaxTest = 1000})

deepCheck p = check (defaultConfig{configMaxTest = 10000}) p

deepCheck = check (defaultConfig{configMaxTest = 10000})

deepestCheck p = check (defaultConfig{configMaxTest = 100000}) p

deepestCheck = check (defaultConfig{configMaxTest = 100000})

[Char]

String

prop_split (str :: [Char]) = ...

propSplit (str :: [Char]) = ...

[Char]

String

prop_spliInSubListsAt (x :: Int) (str :: [Char]) = ...

propSpliInSubListsAt (x :: Int) (str :: [Char]) = ...

[Char]

String

prop_skipGetLastWord (str :: [Char]) = ...

propSkipGetLastWord (str :: [Char]) = ...

Gen [[Char]]

Gen [String]

prop_newIndex_range = ...

propNewIndexRange = ...

prop_newCommandIndex = ...

propNewCommandIndex = ...

l !! (newIndex c l)

l !! newIndex c l

nextCompletion t c l = getNextOfLastWord t c l

nextCompletion = getNextOfLastWord

commandToComplete _ c = getLastWord c

commandToComplete _ = getLastWord

liftIO $ readHistory

liftIO readHistory

if length c > 1 then modify $ \ s -> s{showComplWin = True} else
  return ()

when (length c > 1) $ modify $ \ s -> s{showComplWin = True}

do modify $ \ s -> setCommand "" $ s{offset = 0}

modify $ \ s -> setCommand "" $ s{offset = 0}

liftM insertString $ getSelection

liftM insertString getSelection

o - (ln reverse f)

o - ln reverse f

o + (ln id ss)

o + ln id ss

(completionFunction s) (commandToComplete (xptype s) (command s))

completionFunction s (commandToComplete (xptype s) (command s))

wh `div` (fi max_compl_len)

wh `div` fi max_compl_len

(length compl) `divMod` fi columns

length compl `divMod` fi columns

(length xx) * (length yy)

length xx * length yy

if (compl /= [] && showComplWin st) then
  case complWin st of
      Just w -> case complWinDim st of
                    Just wi -> if nwi == wi then drawComplWin w compl else recreate
                    Nothing -> recreate
      Nothing -> recreate
  else destroyComplWin

if compl /= [] && showComplWin st then
  case complWin st of
      Just w -> case complWinDim st of
                    Just wi -> if nwi == wi then drawComplWin w compl else recreate
                    Nothing -> recreate
      Nothing -> recreate
  else destroyComplWin

dzen str timeout = dzenWithArgs str [] timeout

dzen str = dzenWithArgs str []

['\n']

"\n"

(fromIntegral n) + 1

fromIntegral n + 1

asks dels >>= return . foldr M.delete kmap

liftM (foldr M.delete kmap) (asks dels)

asks ins >>= return . foldr (uncurry M.insert) kmap

liftM (foldr (uncurry M.insert) kmap) (asks ins)

on op f = \ x y -> f x `op` f y

on op f x y = f x `op` f y

mod1Mask + (read [n])

mod1Mask + read [n]

"F" ++ show n

'F' : show n

concat . intersperse " " . map ((++ "\"") . ("\"" ++))

unwords . map ((++ "\"") . ("\"" ++))

dmenu opts = menu "dmenu" opts

dmenu = menu "dmenu"

menu menuCmd opts
  = io $ runProcessWithInput menuCmd [] (unlines opts)

menu menuCmd = io . runProcessWithInput menuCmd [] . unlines

dmenuMap selectionMap = menuMap "dmenu" selectionMap

dmenuMap = menuMap "dmenu"

if
  null
    (filter ((== scratchpadWorkspaceTag) . W.tag) (W.workspaces s))
  then addHiddenWorkspace scratchpadWorkspaceTag else return ()

when
  (null
     (filter ((== scratchpadWorkspaceTag) . W.tag) (W.workspaces s)))
  $ addHiddenWorkspace scratchpadWorkspaceTag

Int -> Word8 -> Int -> [Char]

Int -> Word8 -> Int -> String

Display -> Atom -> [Char] -> XEventPtr -> IO ()

Display -> Atom -> String -> XEventPtr -> IO ()

do forkIO
     ((allocaXEvent $ processEvent dpy ty text) >>
        destroyWindow dpy win)
     >> return ()

forkIO
  ((allocaXEvent $ processEvent dpy ty text) >>
     destroyWindow dpy win)
  >> return ()

do putStrLn "Unable to obtain ownership of the selection" >>
     destroyWindow dpy win

putStrLn "Unable to obtain ownership of the selection" >>
  destroyWindow dpy win

Just $ W.Stack{W.focus = 1, W.up = [], W.down = [1 .. nscr - 1]}

Just W.Stack{W.focus = 1, W.up = [], W.down = [1 .. nscr - 1]}

(scale - (1 % 1)) / (fromIntegral len)

(scale - (1 % 1)) / fromIntegral len

r1 : (divideRects xs r2)

r1 : divideRects xs r2

((fromIntegral n) * (numerator rat)) `div` (denominator rat)

((fromIntegral n) * (numerator rat)) `div` denominator rat

(fromIntegral n) * (numerator rat)

fromIntegral n * numerator rat

decoration s t ds = ModifiedLayout (Decoration (I Nothing) s t ds)

decoration s t = ModifiedLayout . Decoration (I Nothing) s t

describeDeco ds = show ds

describeDeco = show

decorationMouseFocusHook _ s e = handleMouseFocusDrag False s e

decorationMouseFocusHook _ = handleMouseFocusDrag False

decorationMouseDragHook _ s e = handleMouseFocusDrag True s e

decorationMouseDragHook _ = handleMouseFocusDrag True

decorate ds w h r s wrs wr
  = return $ pureDecoration ds w h r s wrs wr

decorate ds w h r s wrs = return . pureDecoration ds w h r s wrs

w `elemIndex` (map (fst . fst) dwrs)

w `elemIndex` map (fst . fst) dwrs

updateDecos s t f = mapM_ $ updateDeco s t f

updateDecos s t = mapM_ . updateDeco s t

isInStack s = flip elem (W.integrate s)

isInStack = flip elem . W.integrate

return $ (zip ws rs, Nothing)

return (zip ws rs, Nothing)

f sh >>= return . fromIntegral . fst

liftM (fromIntegral . fst) (f sh)

layoutHintsWithPlacement rs = ModifiedLayout (LayoutHints rs)

layoutHintsWithPlacement = ModifiedLayout . LayoutHints

description l = show (orientation l)

description = show . orientation

(Rectangle (align al sx sw w) sy w h) :
  (divide al Tall bhs
     (Rectangle sx (sy + fromIntegral h) sw (sh - h)))

Rectangle (align al sx sw w) sy w h :
  divide al Tall bhs (Rectangle sx (sy + fromIntegral h) sw (sh - h))

1 + (length bhs)

1 + length bhs

(Rectangle sx (align al sy sh h) w h) :
  (divide al Wide bhs
     (Rectangle (sx + fromIntegral w) sy (sw - w) sh))

Rectangle sx (align al sy sh h) w h :
  divide al Wide bhs (Rectangle (sx + fromIntegral w) sy (sw - w) sh)

1 + (length bhs)

1 + length bhs

readsPrec p s = map (first expand) $ readsPrec p s

readsPrec p = map (first expand) . readsPrec p

mkToggle1 t = mkToggle (single t)

mkToggle1 = mkToggle . single

maybe l1 id

fromMaybe l1

maybe l2 id

fromMaybe l2

maybe super id

fromMaybe super

maybe l1 id

fromMaybe l1

maybe l2 id

fromMaybe l2

maybe super id

fromMaybe super

maybe super id

fromMaybe super

maybe l1 id

fromMaybe l1

maybe l2 id

fromMaybe l2

maybe l1 id

fromMaybe l1

maybe l2 id

fromMaybe l2

maybe l1 id

fromMaybe l1

maybe l2 id

fromMaybe l2

Just $
  Stack{focus = z, up = reverse $ takeWhile (/= z) xs,
        down = tail $ dropWhile (/= z) xs}

Just
  Stack{focus = z, up = reverse $ takeWhile (/= z) xs,
        down = tail $ dropWhile (/= z) xs}

(flip maybe) id

flip maybe id

(windowArrangeAll $ SF)

windowArrangeAll $ SF

windowArrangeAll $ SF

windowArrangeAll SF

fi x = fromIntegral x

fi = fromIntegral

return . Just $ (Mag (z `addto` 0.1) On t)

return . Just $ Mag (z `addto` 0.1) On t

return . Just $ (Mag (z `addto` (- 0.1)) On t)

return . Just $ Mag (z `addto` (- 0.1)) On t

return . Just $ (Mag (z) Off t)

return . Just $ Mag (z) Off t

Mag (z)

Mag z

return . Just $ (Mag (z) Off t)

return . Just $ Mag (z) Off t

Mag (z)

Mag z

return . Just $ (Mag z On t)

return . Just $ Mag z On t

return . Just $ (Mag z On t)

return . Just $ Mag z On t

x - (max 0 (x + fi w - sx - fi sw))

x - max 0 (x + fi w - sx - fi sw)

y - (max 0 (y + fi h - sy - fi sh))

y - max 0 (y + fi h - sy - fi sh)

resizeHorizontal i = ModifiedLayout (ResizeScreen L i)

resizeHorizontal = ModifiedLayout . ResizeScreen L

resizeVertical i = ModifiedLayout (ResizeScreen T i)

resizeVertical = ModifiedLayout . ResizeScreen T

resizeHorizontalRight i = ModifiedLayout (ResizeScreen R i)

resizeHorizontalRight = ModifiedLayout . ResizeScreen R

resizeVerticalBottom i = ModifiedLayout (ResizeScreen B i)

resizeVerticalBottom = ModifiedLayout . ResizeScreen B

withNewRectangle r = ModifiedLayout (WithNewScreen r)

withNewRectangle = ModifiedLayout . WithNewScreen

resize nr = runLayout ws nr

resize = runLayout ws

named s = ModifiedLayout (Named s)

named = ModifiedLayout . Named

W.modify' $ focusUp'

W.modify' focusUp'

modifyLayout g w r = runLayout w (applyGaps g r)

modifyLayout g w = runLayout w . applyGaps g

d `elem` (map fst conf)

d `elem` map fst conf

workspaceDir s = ModifiedLayout (WorkspaceDir s)

workspaceDir = ModifiedLayout . WorkspaceDir

map ((width' +) . (`div` 2) . (maxw -)) $ ws

map ((width' +) . (`div` 2) . (maxw -)) ws

(zip ups tops) ++ (reverse (zip dns bottoms))

zip ups tops ++ reverse (zip dns bottoms)

x + (fromIntegral mx)

x + fromIntegral mx

y + (fromIntegral my)

y + fromIntegral my

map f $ [0 .. (length dns)]

map f [0 .. (length dns)]

gw * (fromIntegral n)

gw * fromIntegral n

gh * (fromIntegral n)

gh * fromIntegral n

(n - 1) : (cd (n - 1) m)

(n - 1) : cd (n - 1) m

tabBar s t p = decoration s t (TabBar p)

tabBar s t = decoration s t . TabBar

if w < 700 then ((1 / a) * (700 / w)) else 1 / a

if w < 700 then (1 / a) * (700 / w) else 1 / a

if w < 700 then a else (a * w / 700)

if w < 700 then a else a * w / 700

withIM ratio prop = ModifiedLayout $ AddRoster ratio prop

withIM ratio = ModifiedLayout . AddRoster ratio

S.integrate' $ stack

S.integrate' stack

data SWNConfig = SWNC{swn_font :: String, swn_bgcolor :: String,
                      swn_color :: String, swn_fade :: Rational}
               deriving (Read, Show)

data SWNConfig = SWNC{swnFont :: String, swnBgcolor :: String,
                      swnColor :: String, swnFade :: Rational}
               deriving (Read, Show)

redoLayout sn r _ wrs = doShow sn r wrs

redoLayout sn r _ = doShow sn r

maybe lt id

fromMaybe lt

maybe lt id

fromMaybe lt

maybe lf id

fromMaybe lf

maybe lf id

fromMaybe lf

modifyLayout _ w r = runLayout w r

modifyLayout _ = runLayout

maybe l id

fromMaybe l

(ModifiedLayout m') $ maybe l id ml'

ModifiedLayout m' $ maybe l id ml'

maybe l id

fromMaybe l

(ModifiedLayout m') $ maybe l id ml'

ModifiedLayout m' $ maybe l id ml'

(ModifiedLayout m) `fmap` ml'

ModifiedLayout m `fmap` ml'

onWorkspaces wsIds l1 l2 = PerWorkspace wsIds False l1 l2

onWorkspaces wsIds = PerWorkspace wsIds False

mkNewPerWorkspaceT (PerWorkspace wsIds _ lt lf) mlt'
  = (\ lt' -> PerWorkspace wsIds True lt' lf) $ fromMaybe lt mlt'

mkNewPerWorkspaceT (PerWorkspace wsIds _ lt lf)
  = (\ lt' -> PerWorkspace wsIds True lt' lf) . fromMaybe lt

mkNewPerWorkspaceF (PerWorkspace wsIds _ lt lf) mlf'
  = (\ lf' -> PerWorkspace wsIds False lt lf') $ fromMaybe lf mlf'

mkNewPerWorkspaceF (PerWorkspace wsIds _ lt lf)
  = (\ lf' -> PerWorkspace wsIds False lt lf') . fromMaybe lf

maybe l1 id

fromMaybe l1

maybe l2 id

fromMaybe l2

maybe l id

fromMaybe l

io $ sshComplList

io sshComplList

io $ getCommands

io getCommands

if e then (notExecutable f) else return False

if e then notExecutable f else return False

return $ 0

return 0

getWindowProperty32 d a w >>= return . getPID'

liftM getPID' (getWindowProperty32 d a w)

windowPromptGoto c = doPrompt Goto c

windowPromptGoto = doPrompt Goto

windowPromptBring c = doPrompt Bring c

windowPromptBring = doPrompt Bring

windowPromptBringCopy c = doPrompt BringCopy c

windowPromptBringCopy = doPrompt BringCopy

W.currentTag $ ws

W.currentTag ws

doAppend fn s
  = io $ bracket (openFile fn AppendMode) hClose (flip hPutStrLn s)

doAppend fn
  = io . bracket (openFile fn AppendMode) hClose . flip hPutStrLn

io $ getCommands

io getCommands

directoryPrompt c prom job = mkXPrompt (Dir prom) c getDirCompl job

directoryPrompt c prom = mkXPrompt (Dir prom) c getDirCompl

mapM (deleteInputWin . snd) st

mapM_ (deleteInputWin . snd) st

do case mr of
       Just tr -> withDisplay $
                    \ d ->
                      do tw <- mkInputWindow d tr
                         io $ selectInput d tw (exposureMask .|. buttonPressMask)
                         showWindow tw
                         return ((w, r), Just tw)
       Nothing -> return ((w, r), Nothing)

case mr of
    Just tr -> withDisplay $
                 \ d ->
                   do tw <- mkInputWindow d tr
                      io $ selectInput d tw (exposureMask .|. buttonPressMask)
                      showWindow tw
                      return ((w, r), Just tw)
    Nothing -> return ((w, r), Nothing)

\ (f, s) -> (f, reverse s)

second reverse

io $ getCommands

io getCommands

shellPromptHere sp = mkPrompt (spawnHere sp)

shellPromptHere = mkPrompt . spawnHere

shellPromptOn sp ws = mkPrompt (spawnOn sp ws)

shellPromptOn sp = mkPrompt . spawnOn sp

search browser site query = safeSpawn browser $ site query

search browser site = safeSpawn browser . site

site ++ (escape s)

site ++ escape s

if (fst $ break (== ':') s) `elem` ["http", "https", "ftp"] then s
  else (site s)

if (fst $ break (== ':') s) `elem` ["http", "https", "ftp"] then s
  else site s

if t == p then hasPrefix ts ps else False

(t == p) && hasPrefix ts ps

removeColonPrefix str = tail $ snd $ break (== ':') str

removeColonPrefix = tail . snd . break (== ':')

fromList $
  [((keyMask, keySym), function ln limits direction) |
   (keySym, direction) <- zip [xK_Left .. xK_Down] $ enumFrom ToLeft,
   (keyMask, function) <- [(modm, planeMove),
                           (shiftMask .|. modm, planeShift)]]

fromList
  [((keyMask, keySym), function ln limits direction) |
   (keySym, direction) <- zip [xK_Left .. xK_Down] $ enumFrom ToLeft,
   (keyMask, function) <- [(modm, planeMove),
                           (shiftMask .|. modm, planeShift)]]

mod_ columns_ = compose line $ mod (f column) columns_

mod_ = compose line . mod (f column)

mapWindows f ss = W.mapWorkspace (mapWindows' f) ss

mapWindows = W.mapWorkspace . mapWindows'

do windowRect win >>= flip whenJust (setPosition posRef pos . snd)

windowRect win >>= flip whenJust (setPosition posRef pos . snd)

do currentPosition posRef >>= f win

currentPosition posRef >>= f win

Just $ (win, Rectangle x y (w + 2 * bw) (h + 2 * bw))

Just (win, Rectangle x y (w + 2 * bw) (h + 2 * bw))

moveWithin now lower upper
  = if now < lower then lower else if now > upper then upper else now

moveWithin now lower upper
  | now < lower = lower
  | now > upper = upper
  | otherwise = now

insertUp' a s
  = W.modify (Just $ W.Stack a [] [])
      (\ (W.Stack t l r) ->
         if a `elem` t : l ++ r then Just $ W.Stack t l r else
           Just $ W.Stack a (L.delete a l) (L.delete a (t : r)))
      s

insertUp' a
  = W.modify (Just $ W.Stack a [] [])
      (\ (W.Stack t l r) ->
         if a `elem` t : l ++ r then Just $ W.Stack t l r else
           Just $ W.Stack a (L.delete a l) (L.delete a (t : r)))

(tail l) ++ [head l]

tail l ++ [head l]

[last l] ++ (init l)

(last l) : (init l)

[last l] ++ (init l)

[last l] ++ init l

master : (f ws)

master : f ws

(tail l) ++ [head l]

tail l ++ [head l]

[last l] ++ (init l)

(last l) : (init l)

[last l] ++ (init l)

[last l] ++ init l

catch
  (internAtom d "_XMONAD_TAGS" False >>= getTextProperty d w >>=
     wcTextPropertyToTextList d)
  (\ _ -> return [[]])
  >>= return . words . unwords

liftM (words . unwords)
  (catch
     (internAtom d "_XMONAD_TAGS" False >>= getTextProperty d w >>=
        wcTextPropertyToTextList d)
     (\ _ -> return [[]]))

if (s `notElem` tags) then setTags (s : tags) w else return ()

when (s `notElem` tags) $ setTags (s : tags) w

if (s `notElem` tags) then setTags (s : tags) w else return ()

if s `notElem` tags then setTags (s : tags) w else return ()

withTaggedP t f = withTagged' t (winMap f)

withTaggedP t = withTagged' t . winMap

withTaggedGlobalP t f = withTaggedGlobal' t (winMap f)

withTaggedGlobalP t = withTaggedGlobal' t . winMap

withTagged t f = withTagged' t (mapM_ f)

withTagged t = withTagged' t . mapM_

withTaggedGlobal t f = withTaggedGlobal' t (mapM_ f)

withTaggedGlobal t = withTaggedGlobal' t . mapM_

concat . map (W.integrate' . W.stack) . W.workspaces

concatMap (W.integrate' . W.stack) . W.workspaces

(W.current s) : (W.visible s)

W.current s : W.visible s

gets
  (concat . map (W.integrate' . W.stack) . W.workspaces . windowset)
  >>= mapM getTags
  >>= return . nub . concat

liftM (nub . concat)
  (gets
     (concat . map (W.integrate' . W.stack) . W.workspaces . windowset)
     >>= mapM getTags)

concat . map (W.integrate' . W.stack) . W.workspaces . windowset

concatMap (W.integrate' . W.stack) . W.workspaces . windowset

if (sc /= []) then
  mkXPrompt TagPrompt c (mkComplFunFromList' sc)
    (\ s -> withFocused (delTag s))
  else return ()

when (sc /= []) $
  mkXPrompt TagPrompt c (mkComplFunFromList' sc)
    (\ s -> withFocused (delTag s))

if (sc /= []) then
  mkXPrompt TagPrompt c (mkComplFunFromList' sc)
    (\ s -> withFocused (delTag s))
  else return ()

if sc /= [] then
  mkXPrompt TagPrompt c (mkComplFunFromList' sc)
    (\ s -> withFocused (delTag s))
  else return ()

commandMap c = M.fromList c

commandMap = M.fromList

windows $ focusUp

windows focusUp

windows $ focusDown

windows focusDown

windows $ swapUp

windows swapUp

windows $ swapDown

windows swapDown

windows $ swapMaster

windows swapMaster

submap keys = submapDefault (return ()) keys

submap = submapDefault (return ())

maybe def id

fromMaybe def

getWindowAttributes d w >>= return . winAttrs

liftM winAttrs (getWindowAttributes d w)

queryPointer d w >>= return . pointerPos

liftM pointerPos (queryPointer d w)

(x, y) : (pairUp xs)

(x, y) : pairUp xs

actionMenu action = actionMenu' "dmenu" action

actionMenu = actionMenu' "dmenu"

menuMapFunction selectionMap = menuMap menuCmd selectionMap

menuMapFunction = menuMap menuCmd

(- d)

- d

filter wsPred $ pivoted

filter wsPred pivoted

findWsIndex ws wss = findIndex ((== tag ws) . tag) wss

findWsIndex ws = findIndex ((== tag ws) . tag)

length (ls)

length ls

length (rs)

length rs

map (uncurry (++)) .
  zip (map show ([1 ..] :: [Int])) . map ((++) " - " . fst)

zipWith (++) (map show ([1 ..] :: [Int])) . map ((++) " - " . fst)

latin1StringToCCharList str = map (fromIntegral . ord) str

latin1StringToCCharList = map (fromIntegral . ord)

avoidStrutsOn ss = ModifiedLayout (AvoidStruts ss)

avoidStrutsOn = ModifiedLayout . AvoidStruts

do nr <- fmap ($ r) (calcGap ss)
   runLayout w nr

fmap ($ r) (calcGap ss) >>= runLayout w

withUrgencyHook hook conf
  = withUrgencyHookC hook urgencyConfig conf

withUrgencyHook hook = withUrgencyHookC hook urgencyConfig

adjustUrgents f = io $ modifyIORef urgents f

adjustUrgents = io . modifyIORef urgents

adjustReminders f = io $ modifyIORef reminders f

adjustReminders = io . modifyIORef reminders

do when (t == propertyNotify && a == wM_HINTS) $
     withDisplay $
       \ dpy ->
         do WMHints{wmh_flags = flags} <- io $ getWMHints dpy w
            if (testBit flags urgencyHintBit) then
              do adjustUrgents (\ ws -> if elem w ws then ws else w : ws)
                 callUrgencyHook wuh w
              else clearUrgency w
            userCodeDef () =<< asks (logHook . config)

when (t == propertyNotify && a == wM_HINTS) $
  withDisplay $
    \ dpy ->
      do WMHints{wmh_flags = flags} <- io $ getWMHints dpy w
         if (testBit flags urgencyHintBit) then
           do adjustUrgents (\ ws -> if elem w ws then ws else w : ws)
              callUrgencyHook wuh w
           else clearUrgency w
         userCodeDef () =<< asks (logHook . config)

if (testBit flags urgencyHintBit) then
  do adjustUrgents (\ ws -> if elem w ws then ws else w : ws)
     callUrgencyHook wuh w
  else clearUrgency w

if testBit flags urgencyHintBit then
  do adjustUrgents (\ ws -> if elem w ws then ws else w : ws)
     callUrgencyHook wuh w
  else clearUrgency w

xmobar conf = statusBar "xmobar" xmobarPP toggleStrutsKey conf

xmobar = statusBar "xmobar" xmobarPP toggleStrutsKey

sequence $ map (flip catchX (return Nothing)) $ ppExtras pp

mapM (flip catchX (return Nothing)) (ppExtras pp)

(take (n - length end) xs) ++ end

take (n - length end) xs ++ end

"," ++ bg

',' : bg

if b then (f m) else mempty

if b then f m else mempty

move mw = maybe idHook (doF . move') mw

move = maybe idHook (doF . move')

fadeOut amt = flip setOpacity amt

fadeOut = flip setOpacity

fadeInactiveLogHook amt = fadeOutLogHook isUnfocused amt

fadeInactiveLogHook = fadeOutLogHook isUnfocused

do setWindowDesktop win curr

setWindowDesktop win curr

do setWindowDesktop win wn

setWindowDesktop win wn

do windows $ W.focusWindow w

windows $ W.focusWindow w

do killWindow w

killWindow w

do return ()

return ()

['\NUL']

"\NUL"

concat . map splitAtNull

concatMap splitAtNull

newIORef (DynamicHooks{transients = [], permanent = idHook})

newIORef DynamicHooks{transients = [], permanent = idHook}

maybe (Endo id) id

fromMaybe (Endo id)

(q, a) : (transients dh)

(q, a) : transients dh

M.fromList $
  [((modm, xK_p), spawn "dcop kdesktop default popupExecuteCommand"),
   ((modm .|. shiftMask, xK_q), spawn "dcop kdesktop default logout")]

M.fromList
  [((modm, xK_p), spawn "dcop kdesktop default popupExecuteCommand"),
   ((modm .|. shiftMask, xK_q), spawn "dcop kdesktop default logout")]

M.fromList $
  [((modm, xK_p), spawn "krunner"),
   ((modm .|. shiftMask, xK_q),
    spawn
      "dbus-send --print-reply --dest=org.kde.ksmserver /KSMServer org.kde.KSMServerInterface.logout int32:1 int32:0 int32:1")]

M.fromList
  [((modm, xK_p), spawn "krunner"),
   ((modm .|. shiftMask, xK_q),
    spawn
      "dbus-send --print-reply --dest=org.kde.ksmserver /KSMServer org.kde.KSMServerInterface.logout int32:1 int32:0 int32:1")]

[((modm, xK_semicolon), sendMessage (IncMasterN (- 1)))] ++
  [((m .|. modm, k), windows $ f i) |
   (i, k) <- zip (workspaces conf)
               [38, 233, 34, 39, 40, 45, 232, 95, 231, 224],
   (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)]]

((modm, xK_semicolon), sendMessage (IncMasterN (- 1))) :
  [((m .|. modm, k), windows $ f i) |
   (i, k) <- zip (workspaces conf)
               [38, 233, 34, 39, 40, 45, 232, 95, 231, 224],
   (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)]]

M.fromList $
  [((modm, button1), (\ w -> focus w >> mouseMoveWindow w)),
   ((modm, button2), (\ w -> focus w >> windows W.swapMaster)),
   ((modm .|. shiftMask, button1),
    (\ w -> focus w >> mouseResizeWindow w))]

M.fromList
  [((modm, button1), (\ w -> focus w >> mouseMoveWindow w)),
   ((modm, button2), (\ w -> focus w >> windows W.swapMaster)),
   ((modm .|. shiftMask, button1),
    (\ w -> focus w >> mouseResizeWindow w))]

M.fromList $
  [((modm, xK_p), shellPromptHere sp myPromptConfig),
   ((modm .|. shiftMask, xK_c), kill1),
   ((modm .|. shiftMask .|. controlMask, xK_c), kill),
   ((modm .|. shiftMask, xK_0), windows $ \ w -> foldr copy w ws),
   ((modm, xK_z), layoutScreens 2 $ TwoPane 0.5 0.5),
   ((modm .|. shiftMask, xK_z), rescreen)]

M.fromList
  [((modm, xK_p), shellPromptHere sp myPromptConfig),
   ((modm .|. shiftMask, xK_c), kill1),
   ((modm .|. shiftMask .|. controlMask, xK_c), kill),
   ((modm .|. shiftMask, xK_0), windows $ \ w -> foldr copy w ws),
   ((modm, xK_z), layoutScreens 2 $ TwoPane 0.5 0.5),
   ((modm .|. shiftMask, xK_z), rescreen)]

M.fromList $
  [((modm, xK_p), spawn "xfrun4"),
   ((modm .|. shiftMask, xK_p), spawn "xfce4-appfinder"),
   ((modm .|. shiftMask, xK_q), spawn "xfce4-session-logout")]

M.fromList
  [((modm, xK_p), spawn "xfrun4"),
   ((modm .|. shiftMask, xK_p), spawn "xfce4-appfinder"),
   ((modm .|. shiftMask, xK_q), spawn "xfce4-session-logout")]

M.fromList $ [((modm, xK_b), sendMessage ToggleStruts)]

M.fromList [((modm, xK_b), sendMessage ToggleStruts)]

desktopLayoutModifiers layout = avoidStruts layout

desktopLayoutModifiers = avoidStruts

Layout $ Full

Layout Full