voidcruiser-test.nl/content/rambles/xmonad-prompts.md

title	date	author	tags	description	toc
XMonad Promtps	2023-03-08T14:20:11+01:00	$HUMANOID	haskell xmonad linux	There aren't a lot of instructions or explanatiosn on creating XMonad prompts, or at least not within a minute of checking my searx instance.	true

Introduction

XMonad has it's own prompt system. Some time ago, I wanted to see if it could replace dmenu entirely. I managed it for the more common usages I had for it. My application launcher, ssh prompt and pass interface were easy to replace using standard XMonad Contrib modules (XMonad.Prompt.Shell, XMonad.Prompt.Ssh and XMonad.Prompt.Pass respectively). However, things became more difficult when it came to my universal/external Qutebrowser bookmarks menu and yt-dlp-and-pipe-viewer wrapper.

Bookmarks menu

The first one I decided to tackle was the bookmarks menu, as it is by far the simplest of the two.

Let's take a look at the original:

#!/bin/sh
bookmarks="$HOME/.config/qutebrowser/bookmarks/urls"
choice="$(awk '{print$1}' $bookmarks | sort | dmenu -p "Bookmark:" -l 30)"
[ -z $choice ] || qutebrowser "$choice"

Things get interesting at the declaration of the choice variable:

1. It takes the contents of Qutebrowser's bookmarks file
2. It sorts the results of that
3. Sends that to dmenu, prompting the user to make a choice

After this, it checks whether choice is empty or not and in case it isn't, opens Qutebrowser with its contents.

{{< start-details summary="Here is an example of how Qutebrowser saves its bookmarks" >}}

https://www.alpinelinux.org/ index | Alpine Linux
https://www.openbsd.org/ftp.html OpenBSD: Mirrors
https://commonmark.org/ CommonMark
https://xxiivv.com/ Echorridoors
https://100r.co/site/home.html 100R — home
https://solar.lowtechmagazine.com/about.html About this website | LOW←TECH MAGAZINE

{{< end-details >}}

Implementation

Its functionality does boils down to the following:

1. Parse a given file according to a set of rules, returning it's contents in the form of a list
2. Allow the user to make a choice from that list
3. Launch an application with that choice as parameter

Seems easy enough to implement.

Parsing the Bookmarks file

Lets start off by creating a function that can parse our bookmarks file. Here we need something to read a file -- in this case a bookmars file -- and return its contents in the form of a list. So lets create a function that takes an arbitrary file path and reads its contents, returning them as a list of strings.

fileContentList :: FilePath -> IO [String]

This function takes a filepath and returns IO [String]. This is to accommodate that it has to read a file.

Now for the rest of the function:

fileContentList :: FilePath -> IO [String]
fileContentList f = do
    homeDir <- getEnv "HOME"
    file <- readFile (homeDir ++ "/" ++ f)
    return . uniqSort . lines $ file

Lets go over what is happening here.

fileContentList is a function that takes an argument f.

First, it retrieves the current home directory based on the $HOME environment variable and binds it to homeDir using the getEnv function from the System.Environment module. getEnv returns a string with the contents of the variable given as its argument.

Next, it retrieves the file contents from $HOME/path/to/file using the readFile. This path is created by appending f to the homeDir.

Now for the final line.

First it takes the file and splits it up into a list of strings based on \n using the lines function.

    lines $ file

Then it pipes the result from that into uniqSort from the XMonad.Prompt module in order to -- as the name implies -- sort it and get rid of any duplicate items.

    uniqSort . lines $ file

And the output of that is piped into return:

    return . uniqSort . lines $ file

This function will allows us to parse any given text file. To parse the Qutebrowser bookmarks file, call it using .config/qutebrowser/bookmarks/url

Creating a Prompt

Lets see if there is anything in the XMonad.Prompt module that looks like it could help us in creating a prompt.

---

mkXPrompt :: XPrompt p => p -> XPConfig -> ComplFunction -> (String -> X ()) -> X ()

Creates a prompt given:

• a prompt type, instance of the XPrompt class.
• a prompt configuration (def can be used as a starting point)
• a completion function (mkComplFunFromList can be used to create a completions function given a list of possible completions)
• an action to be run: the action must take a string and return X ()

---

This looks like it could serve as the basis for our prompt. The description and type signature tell us that it is going to require an instance of the XPrompt typeclass. So lets create a Bookmark datatype and implement the showXPrompt function from XPrompt in order to give it a default message when executed and thereby having it derive from XPrompt.

data Bookmark = Bookmark

instance XPrompt Bookmark where
    showXPrompt Bookmark = "Bookmark: "

As its second argument, mkXPrompt requires an instance of XPConfig. The XPConfig typeclass is where you -- as the name implies -- specify the configuration of XMonad's prompts. Knowing this we can start to write function that uses mkXPrompt:

bookmarkPrompt c = do
    mkXPrompt Bookmark c

c is our XPConfig argument.

This takes care of the XPrompt p => p -> XPConfig portion of the function.

Now for the completion function, that will handle the list given to our prompt. Lets mostly follow the suggestion in the description of mkXPrompt and lets take a look at:

---

mkComplFunFromList' :: XPConfig -> [String] -> String -> IO [String]

This function takes a list of possible completions and returns a completions function to be used with mkXPrompt. If the string is null it will return all completions.

---

This is how Qutebrowser and dmenu act by default with a given list of possible options.

So it takes an instance of XPConfig -- that will be our c argument, and a list of strings. Here is where we feed it the contents of our file using our fileContentList function.

bookmarkPrompt c = do
    bl <- io fileContentList 
    mkXPrompt Bookmark c (mkComplFunFromList' c bl)