How To Configure XMonad Keyboard Shortcuts

data

Haskell keyword to signal that the rest of the expression defines a new data type. ➡ in-depth explanation

data XConfig = XConfig

New custom data type definition. The left XConfig is the type name, the right XConfig is the value constructor to build actual values. Both usually have the same name for simplicity, but are used differently. ➡ in-depth explanation

{ .. }

Definition of the payload; define what data a value of XConfig contains.

::

Read as “has type”.

KeyMask

A type for special “modifier” keyboard keys like Ctrl. ➡ mod-keys

->

Haskell keyword for a function type. ➡ Haskell function syntax

XConfig -> Map ..

The type of a function that takes an XConfig value as input and produces a Map value. ➡ Haskell function syntax

Map (ButtonMask,KeySym) (X ())

A mapping from key combinations to XMonad actions.

(ButtonMask,KeySym)

Pair-Type of a special keyboard key and a regular keyboard key.

ButtonMask

Another type for “modifier” keyboard keys, identical to KeyMask. ➡ mod-keys

KeySym

Short for “Keyboard symbol”. A type for regular keyboard keys like A. ➡ all KeySym values

This is a simplified version of the real XMonad code ➡ default keys source code and ➡ default XConfig source code.

defaultKeys

Custom name for our function that takes an XConfig value as input and returns a Map value. ➡ Haskell function syntax

conf@(XConfig {modMask = modMask})

The single argument to the defaultKeys function.

conf@

Haskell’s “As pattern”. The whole argument value gets a name conf that we can use in the rest of the function, like in spawn $ terminal conf. ➡ as pattern

(XConfig {modMask = modMask})

Pattern matching/destructuring the argument value of defaultKeys to extract only the modifier key value modMask. ➡ pattern matching

{modMask = modMask}

Extract the modifier key value from an XConfig value. The left modMask is what to pattern match against, and the right is a custom name for that value that we can use in the rest of the function, as in (modMask .|. shiftMask).... ➡ pattern matching We could have also used another local name:

-- conceptual XMonad default config code
defaultKeys conf@(XConfig {modMask = localModKey}) = Map.fromList $
 [ ((localModKey .|. shiftMask, xK_Return), spawn $ terminal conf) 
 , ((localModKey,               xK_p     ), spawn "dmenu_run") 
 ..
 ]

Map.fromList

A helper function to construct a Map from the given list of keys-and-action pairs. ➡ fromList documentation

.|.

A function to combine two modifier keys. ➡ documentation

shiftMask

A Haskell value that represents the Shift key.

xK_Return

A Haskell value that represent the Enter key. ➡ all keyboard values

spawn

A function that executes the given terminal command, e.g. spawn "firefox" launches the Firefox browser. ➡ documentation

$

A helper function to write fewer parentheses. ➡ $ explanation

terminal

A function that extracts the terminal app name from a given XConfig value, e.g. terminal conf usually returns the string "xterm" (the default terminal app).

[ .. , .. ]

A list in Haskell. Elements are separated by comma.

XConfig { .. }

Construct a XConfig value. Here we only focus on the shortcut-related modMask and keys fields. ➡

def

Variable name that holds the standard XConfig value as configured by the XMonad authors. ➡ source code

import

Load functions and values from other Haskell packages. ➡ Import syntax

myKeys

Custom name for our function that takes an XConfig value as input and returns a Map value with our shortcuts. ➡ Haskell function syntax

conf@(XConfig {modMask = modKey})

The single argument to the myKeys function.

conf@

Haskell’s “As pattern”. The whole argument value gets a name conf that we can use in the rest of the function, e.g. spawn $ terminal conf. ➡ as pattern

(XConfig {modMask = modKey})

Pattern matching/destructuring the argument value of myKeys to extract only the modifier key value modMask. The left modMask is what to pattern match against, and the right modKey is a custom name for that value that we can use in the rest of the function, as in (modKey, xK_f).... ➡ pattern matching

xK_f

A Haskell value that represent the f key. ➡ all keyboard values

spawn

An XMonad function that executes the given terminal command, e.g. spawn "firefox" launches a Firefox browser. ➡ documentation

((modKey, xK_f), spawn "firefox")

A shorcut that opens the Firefox browser, when we press Mod + f.

[ .. , .. ]

A list in Haskell. Elements are separated by comma.

def

Variable that holds a default XConfig value configured by the XMonad creators. ➡ source code

myConfig

Custom variable for our configured XConfig value but without our shortcuts.

def { modMask = mod4Mask }

Create a copy of def containing our modifications. We replace the old modMask value with mod4Mask, which represents the Win key. ➡ Override notation

myConfig'

A slight variant of myConfig that also contains our custom shortcuts. The single quote ' at the end (pronounced “prime” in Math and Haskell) makes it a completely different name to XMonad, but we use it to express that it’s just a small variation of myConfig (without the single quote). In Haskell it is common to add ' to a name of a value that is just a small variation of another value, because inventing new good names is hard.

`additionalKeys`

A helper function (in infix notation) to add our shortcuts to the built-in ones. It takes two arguments, an XConfig value and a list(! not a Map) of shortcuts, and creates a new XConfig value. ➡ Function infix notation
➡ Documentation