-----------------------------------------------------------------------------
-- |
-- Module      :  XMonad.Actions.Sift
-- Description :  Functions for sifting windows up and down.
-- Copyright   :  (c) 2020 Ivan Brennan <ivanbrennan@gmail.com>
-- License     :  BSD3-style (see LICENSE)
--
-- Maintainer  :  Ivan Brennan <ivanbrennan@gmail.com>
-- Stability   :  stable
-- Portability :  unportable
--
-- Functions for sifting windows up and down. Sifts behave identically to
-- swaps (i.e. 'swapUp' and 'swapDown' from "XMonad.StackSet"), except in
-- the wrapping case: rather than rotating the entire stack by one position
-- like a swap would, a sift causes the windows at either end of the stack
-- to trade positions.
--
-----------------------------------------------------------------------------

module XMonad.Actions.Sift (
    -- * Usage
    -- $usage
    siftUp,
    siftDown,
  ) where

import XMonad.StackSet (Stack (Stack), StackSet, modify')
import XMonad.Util.Stack (reverseS)

-- $usage
-- You can use this module with the following in your @xmonad.hs@:
--
-- > import XMonad.Actions.Sift
--
-- and add keybindings such as the following:
--
-- >   , ((modMask .|. shiftMask, xK_j ), windows siftDown)
-- >   , ((modMask .|. shiftMask, xK_k ), windows siftUp  )
--

-- |
-- siftUp, siftDown. Exchange the focused window with its neighbour in
-- the stack ordering, wrapping if we reach the end. Unlike 'swapUp' and
-- 'swapDown', wrapping is handled by trading positions with the window
-- at the other end of the stack.
--
siftUp, siftDown :: StackSet i l a s sd -> StackSet i l a s sd
siftUp :: forall i l a s sd. StackSet i l a s sd -> StackSet i l a s sd
siftUp   = forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
modify' forall a. Stack a -> Stack a
siftUp'
siftDown :: forall i l a s sd. StackSet i l a s sd -> StackSet i l a s sd
siftDown = forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
modify' (forall a. Stack a -> Stack a
reverseS forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Stack a -> Stack a
siftUp' forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Stack a -> Stack a
reverseS)

siftUp' :: Stack a -> Stack a
siftUp' :: forall a. Stack a -> Stack a
siftUp' (Stack a
t (a
l:[a]
ls) [a]
rs) = forall a. a -> [a] -> [a] -> Stack a
Stack a
t [a]
ls (a
lforall a. a -> [a] -> [a]
:[a]
rs)
siftUp' (Stack a
t []     [a]
rs) =
  case forall a. [a] -> [a]
reverse [a]
rs of
    (a
x:[a]
xs) -> forall a. a -> [a] -> [a] -> Stack a
Stack a
t ([a]
xs forall a. [a] -> [a] -> [a]
++ [a
x]) []
    []     -> forall a. a -> [a] -> [a] -> Stack a
Stack a
t []          []