Format with ormolu.

1 files changed, 52 insertions, 46 deletions

diff --git a/src/Rahm/Desktop/Theater.hs b/src/Rahm/Desktop/Theater.hs
index d000f75..7ec1cd4 100644
--- a/src/Rahm/Desktop/Theater.hs
+++ b/src/Rahm/Desktop/Theater.hs
@@ -1,25 +1,22 @@
 module Rahm.Desktop.Theater where
 
-
 -- A "Theater" is the state of a stackset. One can save the current stackset as
 -- a "theater" and then restore it later. If new windows were added, those new
 -- windows are put into the hidden workspace.
 
-import qualified XMonad as X
-import qualified XMonad.StackSet as W
-import qualified XMonad.Util.ExtensibleState as XS
-
-import XMonad (X)
-import Data.List ((\\), sortOn)
-import Data.Typeable
-import Data.Proxy
-import Data.Maybe
-import Data.Default
 import Control.Monad (forM_)
+import Data.Default
+import Data.List (sortOn, (\\))
 import Data.Map (Map)
 import qualified Data.Map as Map
-
+import Data.Maybe
+import Data.Proxy
+import Data.Typeable
 import Rahm.Desktop.Logger
+import XMonad (X)
+import qualified XMonad as X
+import qualified XMonad.StackSet as W
+import qualified XMonad.Util.ExtensibleState as XS
 
 type WinSet = W.StackSet X.WorkspaceId String X.Window X.ScreenId X.ScreenDetail
 
@@ -28,10 +25,11 @@ newtype Theater = Theater WinSet
 
 type TheaterName = Maybe String
 
-data Theaters = Theaters {
-    currentTheater :: TheaterName
-  , theaters :: Map TheaterName Theater
-  } deriving (Read, Show)
+data Theaters = Theaters
+  { currentTheater :: TheaterName,
+    theaters :: Map TheaterName Theater
+  }
+  deriving (Read, Show)
 
 instance Default Theaters where
   def = Theaters Nothing mempty
@@ -59,7 +57,6 @@ saveTheater name ws = do
       if isStackSetEmpty "*" ws && not (name == cur)
         then Map.delete name map
         else Map.insert name (Theater $ unboxLayout ws) map
-
   where
     unboxLayout = W.mapLayout show
 
@@ -79,16 +76,20 @@ restoreTheater name = do
     case Map.lookup name mp of
       Nothing -> do
         ws <- X.windowset <$> X.get
-        return $ W.mapWorkspace (
-            \(W.Workspace i l _) -> W.Workspace i l Nothing) ws
-
+        return $
+          W.mapWorkspace
+            ( \(W.Workspace i l _) -> W.Workspace i l Nothing
+            )
+            ws
       Just (Theater ws) ->
-        return $ W.mapLayout (
-          \serialized -> case [x | (x, "") <- X.readsLayout currentLayout serialized] of
-            [x] -> x
-            [] -> currentLayout
-            (_:_) -> currentLayout
-          ) ws
+        return $
+          W.mapLayout
+            ( \serialized -> case [x | (x, "") <- X.readsLayout currentLayout serialized] of
+                [x] -> x
+                [] -> currentLayout
+                (_ : _) -> currentLayout
+            )
+            ws
 
   let newStackSet = updateStateWithWindows (W.allWindows currentWindowset) "*" newStackSet'
 
@@ -100,28 +101,33 @@ restoreTheater name = do
 
 isStackSetEmpty ::
   (Eq i, Eq a) => i -> W.StackSet i l a si sd -> Bool
-isStackSetEmpty hiddenWorkspace = all (
-  \(W.Workspace t l s) -> isNothing s || t == hiddenWorkspace ) . W.workspaces
-
+isStackSetEmpty hiddenWorkspace =
+  all
+    ( \(W.Workspace t l s) -> isNothing s || t == hiddenWorkspace
+    )
+    . W.workspaces
 
 updateStateWithWindows ::
   (Eq i, Eq a) => [a] -> i -> W.StackSet i l a si sd -> W.StackSet i l a si sd
 updateStateWithWindows allWindows hiddenWorkspace ss =
   let missingWindows = allWindows \\ W.allWindows ss
-      layout = W.layout $ W.workspace $ W.current ss in
-    if null missingWindows
-      then ss
-      else
-        if not (W.tagMember hiddenWorkspace ss)
-          then 
-            ss { W.hidden =
-              W.Workspace hiddenWorkspace layout (W.differentiate missingWindows)
-              : W.hidden ss}
-
-          else
-            W.mapWorkspace (\(W.Workspace t l s') ->
-              let s = W.filter (`elem`allWindows) =<< s' in
-              if t == hiddenWorkspace
-                then
-                  W.Workspace t l (W.differentiate $ W.integrate' s ++ missingWindows)
-                else W.Workspace t l s) ss
+      layout = W.layout $ W.workspace $ W.current ss
+   in if null missingWindows
+        then ss
+        else
+          if not (W.tagMember hiddenWorkspace ss)
+            then
+              ss
+                { W.hidden =
+                    W.Workspace hiddenWorkspace layout (W.differentiate missingWindows) :
+                    W.hidden ss
+                }
+            else
+              W.mapWorkspace
+                ( \(W.Workspace t l s') ->
+                    let s = W.filter (`elem` allWindows) =<< s'
+                     in if t == hiddenWorkspace
+                          then W.Workspace t l (W.differentiate $ W.integrate' s ++ missingWindows)
+                          else W.Workspace t l s
+                )
+                ss