Mapping from workspace tag to master history list. The current master is the head of the list, the previous master the second element, and so on. Without history, the list is empty.

Return the master history map from the state.

Return the master history list of a given tag. The master history list may be empty. An invalid tag will also result in an empty list.

Return the master history list of the current workspace.

Return the master history list of the workspace containing the given window. Return an empty list if the window is not in the stackset.

Modify the master history list of a given workspace, or the empty list of no such workspace is mapped. The result is then re-inserted into the master history map.

Modify the master history list of the current workspace. While the current workspace is guaranteed to exist; its master history may not. For more information see modifyMasterHistoryFromTag.

A logHook to update the master history mapping. Non-existent workspaces are removed, and the master history list for the current workspaces is updated. See masterHistoryHook'.

Backend for masterHistoryHook.

Given the current master history list and an integrated stack, return the new master history list. The current master is either moved (if it exists within the history) or added to the head of the list, and all missing (i.e. closed) windows are removed.

Wrap swapPromoteStack; see also swapApply.

Like swapPromote' but discard the result.

Wrap swapInStack; see also swapApply.

Like swapIn' but discard the result.

Wrap swapHybridStack; see also swapApply.

Like swapHybrid' but discard the result.

Apply the given master history stack modifier to the current stack. If given True, all non-focused floating windows will be ignored. Return True if insufficient history; if so use whenX to sequence a backup promotion function.

If the focused window is the master window and there is no previous master, do nothing. Otherwise swap the master with the previous master. If the focused window is not the master window, swap it with the master window. In either case focus follows the original window, i.e. the focused window does not change, only its position.

The first argument is the previous master (which may not exist), the second a window stack. Return True if the master history hindered the swap; the history is either empty or out-of-sync. Though the latter shouldn't happen this function never changes the stack under such circumstances.

Perform the same swap as swapPromoteStack. However the new window receives the focus; it appears to "swap into" the position of the original window. Under this model focus follows stack position and the zipper does not move.

See swapPromoteStack for more details regarding the parameters.

If the focused window is the master window, use swapInStack. Otherwise use swapPromoteStack.

See swapPromoteStack for more details regarding the parameters.

Cycle a list by the given count. If positive, cycle to the left. If negative, cycle to the right:

>>> cycleN 2 [1,2,3,4,5]
[3,4,5,1,2]
>>> cycleN (-2) [1,2,3,4,5]
[4,5,1,2,3]

Wrap split' with an initial index of 0, discarding the list's length.

Given a predicate, an initial index and a list, return a tuple containing:

• List length.
• Indexed list of elements which satisfy the predicate. An indexed element is a tuple containing the element index (offset by the initial index) and the element.
• List of elements which do not satisfy the predicate.

The initial index and length of the list simplify chaining calls to this function, such as for zippers of lists.

Wrap merge' with an initial virtual index of 0. Return only the unindexed list with elements from the leftover indexed list appended.

Inverse of split. Merge an indexed list with an unindexed list (see split'). Given a virtual index, an indexed list and an unindexed list, return a tuple containing:

• Virtual index after the unindexed list
• Remainder of the indexed list
• Merged unindexed list

If the indexed list is empty, this functions consumes the entire unindexed list. If the unindexed list is empty, this function consumes only adjacent indexed elements. For example, [(10,"ten"),(12,"twelve")] implies missing unindexed elements and so once (10,"ten") is consumed this function concludes.

The indexed list is assumed to have been created by split' and not checked for correctness. Indices are assumed to be ascending, i.e. > [(1,"one"),(2,"two"),(4,"four")]

The initial and final virtual indices simplify chaining calls to the this function, as as for zippers of lists. Positive values shift the unindexed list towards the tail, as if preceded by that many elements.

Remove all elements of the set from the stack. Skip the currently focused member. Return an indexed list of excluded elements and the modified stack. Use stackMerge to re-insert the elements using this list.

Inverse of stackSplit. Given a list of elements and their original indices, re-insert the elements into these same positions within the stack. Skip the currently focused member. Works best if the stack's length hasn't changed, though if shorter any leftover elements will be tacked on.