#A M      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L,Code that will be imported into every module(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code)None,4567=>?@ACHMPSVX_`|f  $+*%,& r'( $#)"! *+~}|{zyx,^-ON  ML.lqponm/01     2)('&%3f4567"!#`_89:;<=SV>?@ABCDEFGHTUIYZ[JKLMNOPQWXR\]^`_uacbdeghijklmnopqrtsvw-./0123456789:;<=>?@ABCDEFGHIJKPQRSTUVWXYZ[\]baedcgfhijkstuvwxyz{|}~      "!#%$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJLKNMOPQRSTUVWXYZ[\^]_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bacfedghijklmnopqrstuvwxyz{|}~     ! "$#&%'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghnmlkjioqprsuvutwyx{z|}~  $+*%,& r'( $#)"! *+~}|{zyx,^-ON  ML.lqponm/01     2)('&%3f4567"!#`_89:;<=SV>?@ABCDEFGHTUIYZ[JKLMNOPQWXR\]^`_uacbdeghijklmnopqrtsvw-./0123456789:;<=>?@ABCDEFGHIJKPQRSTUVWXYZ[\]baedcgfhijkstuvwxyz{|}~      "!#%$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJLKNMOPQRSTUVWXYZ[\^]_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bacfedghijklmnopqrstuvwxyz{|}~     ! "$#&%'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghnmlkjioqprsuvutwyx{z|}~A list of compose-sequences(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`kmonadA collection of all supported compose-key sequences (nearly all X11 compose-key sequences). Each tuple consists of: 1. A string that, when parsed to a tap-macro, will emit the sequence. 2. The UTF-8 character that it represents 3. A descriptive-name"Parse command-line options into a  for KMonad to execute(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code)None,4567=>?@ACHMPSVX_`L kmonad+Record describing the instruction to KMonadkmonad"Which file to read the config fromkmonad)Flag to indicate we are only test-parsingkmonadLevel of logging to usekmonadParse # from the evocation of this program MkmonadParse the full command Nkmonad2Parse a filename that points us at the config-file Okmonad8Parse a flag that allows us to switch to parse-only mode Pkmonad>Parse the log-level as either a level option or a verbose flag  0A `k -> Set v` mapping, with reversing utilities(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`kmonadThe 0, which describes a one to many (unique) mapping QkmonadIAll the type constraints required for something to function as a MultiMapkmonad?Create a new multimap from a foldable of (k, foldable v) pairs.kmonad5Create a new multimap from a foldable of (k, v) pairskmonad&A fold over all the (k, v) pairs in a kmonadHReverse a MultiMap. Note: this is not necessarily a lossless conversion.%Description of all possible keycodes.(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,45679=>?@ACHMPSVX_`ԪkmonadThe  datatype, as an % of all the values a  can take. RkmonadThe set of all existing  SkmonadThe set of all & that are not of the MissingXX pattern Tkmonad*Helper function to generate easy name mapskmonadA collection of  to { mappings Ukmonad8A collection of useful aliases to refer to keycode names      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#A container of overlapping mappings(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`kmonad$The things that can go wrong with a kmonad%Requested use of a non-existing layerkmonad"Requested use of a non-stack layerkmonadA I is a named collection of maps and a sequence of maps to use for lookup. VkmonadThe current stack of layers Wkmonad A set of all  names XkmonadThe map of all the bindingskmonadA ' is one of the maps contained inside a  YkmonadSThe type of things that can function as either layer or item keys in a LayerStack.kmonad Create a new  from a 8 of key-value pairskmonad Create a new  from a foldable of foldables.kmonad?Return a fold of all the items currently mapped to the item-keyThis can be used with `^ to get an overview of all the items currently mapped to an item-key, or more usefully, with D8 to simply try a lookup like this: `stack^? atKey KeyA`kmonadATry to look up a key in a specific layer, regardless of the stackkmonad9Add a layer to the front of the stack and return the new .If the  does not exist, return a  . If the 1 is already on the stack, bring it to the front.kmonadYRemove a layer from the stack. If the layer index does not exist on the stack, return a 3, if the layer index does not exist at all in the  , return a .kmonadThe alist of alists describing the mappingBasic keyboard types(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,45679=>?@ACHMPSVX_`{kmonadAn  is a  on a particular  Zkmonad Whether the  was a  or  [kmonadThe  mapped to this kmonadwKMonad recognizes 2 different types of actions: presses and releases. Note that we do not handle repeat events at all.kmonads are mappings from  d maps from  to things.kmonad0Layers are identified by a tag that is simply a { value.kmonadPredicate on KeyEvent'skmonad Create a new  from a  and a kmonad Create a  that represents pressing a keykmonad Create a ! that represents releaseing a keykmonad/Return whether the provided KeyEvent is a Presskmonad1Return whether the provided KeyEvent is a ReleasekmonadAReturn whether the provided KeyEvent matches a particular Keycode kmonadHReturth whether the provided KeyEvent matches the release of the Keycode kmonadEReturn whether the provided KeyEvent matches the press of the Keycode kmonadAn .3 instance, where Press > Release, and otherwise we . on the  kmonadA  instance for s that prints them out nicely.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    1The component that provides pausing functionality(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`p  kmonadThe   environment.NOTE:  * has no internal multithreading, i.e. its @ action will never be interrupted, therefore we can simply use ) and sidestep all the STM complications. \kmonadWhere we get our s from ]kmonad.How many locks have been applied to the sluice ^kmonad,Internal buffer to store events while closed _kmonad Create a new   environmentkmonad Create a new  * environment, but do so in a ContT contextkmonadIncrease the block-count by 1kmonadSet the Sluice to unblocked mode, return a list of all the stored events that should be rerun, in the correct order (head was first-in, etc).(NOTE: After successfully unblocking the  t will be empty, it is the caller's responsibility to insert the returned events at an appropriate location in the .5We do this in KMonad by writing the events into the  &s rerun buffer. (this happens in the  KMonad.App module.) `kmonadTry to read from the Sluice, if we are blocked, store the event internally and return Nothing. If we are unblocked, return Just the KeyEvent.kmonadAKeep trying to read from the Sluice until an event passes through   Component for async reading.(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`)kmonadThe  environment akmonadHow to read 1 event bkmonadStore for reading process ckmonadBuffer for rerunning events dkmonad Create a new  environmentkmonad Create a new  environment in a  environmentkmonadReturn the next event, this will return either (in order of precedence): 1. The next item to be rerun 2. A new item read from the OS 3. Pausing until either 1. or 2. triggerskmonad#Add a list of elements to be rerun. 4Various bits and bobs that I don't know where to put(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`B kmonadNewtype wrapper around A& to add type safety to our time valueskmonad9Calculate how much time has elapsed between 2 time pointskmonadmA helper function that helps to throw errors when a return code is -1. Easiest when used as infix like this: .someFFIcall `onErr` MyCallFailedError someDatakmonadEmbed the action of using an  in a continuation monadkmonad/Log an error message and then rethrow the error&Particularly useful as a suffix using . i.e. 3doSomething `catch` logRethrow "I caught something"kmonadLaunch a process that repeats an action indefinitely. If an error ever occurs, print it and rethrow it. Ensure the process is cleaned up upon error and/or shutdown.kmonadELike withLaunch, but without ever needing access to the async processkmonadLike , but in the ContT monadkmonadLike , but in the ContT monadkmonadThe earlier timepointkmonadThe later timepointkmonad(The time in milliseconds between the twokmonadThe error to throwkmonad&The name of this process (for logging)kmonadThe action to repeat foreverkmonadThe foreground action to runkmonadThe resulting actionkmonad&The name of this process (for logging)kmonadThe action to repeat foreverkmonadThe foreground action to runkmonadThe resulting actionkmonad&The name of this process (for logging)kmonadThe action to repeat foreverkmonad&The name of this process (for logging)kmonadThe action to repeat forever   ;The logic behind sending and receiving key events to the OS(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code)None,45679=>?@ACHMPSVX_`N )kmonadA ) is an action that awaits  s from the OS*kmonadA * sends key actions to the OS+kmonad Create a new *,kmonadEmit a key to the OS-kmonadCreate a new KeySource.kmonad!Wait for the next key from the OS+kmonadAction to acquire the keysinkkmonadAction to close the keysinkkmonad Action to write with the keysink-kmonadAction to acquire the keysinkkmonadAction to close the keysinkkmonad Action to write with the keysink)*+,-.*+,)-. $The types particular to Linux key IO(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code)None,4567=>?@ACHMPSVX_`X9/kmonadThe LinuxKeyEvent datatype1kmonad0A smart constructor that casts from any integral2kmonad]Constructor for linux sync events. Whenever you write an event to linux, you need to emit a 2< to signal to linux that it should sync all queued updates.3kmonad Translate a / to a kmonad 4kmonadTranslate kmonad  along with a  e to /s for writing.1kmonad The tuple representing the eventkmonadThe LinuxKeyEvent      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  )*+,-./01234/01243 -Using Linux's uinput interface to emit events(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,45679=>?@ACHMPSVX_`l fkmonad6A collection of everything that can go wrong with the C gkmonadCould not register device hkmonadCould not release device ikmonadCould not decode event9kmonad3Configuration of the Uinput keyboard to instantiateCkmonad%UinputSink is an MVar to a filehandleIkmonadDefault Uinput configurationKkmonadReturn a new uinput * with extra options jkmonad"Create and acquire a Uinput device kkmonadRelease a Uinput device lkmonad?Using a Uinput device, send a LinuxKeyEvent to the Linux kernel mkmonadCreate a new UinputSink nkmonadClose a C okmonadWrite a keyboard event to the sink and sync the driver state. Using an MVar ensures that we can never have 2 threads try to write at the same time. pkmonad Posix handle to the file to openkmonadName to give to the keyboardkmonad Vendor IDkmonad Product IDkmonad Version ID9:;<=>?CDHFGEIKC9:;<=>?DHFGEKILoad and acquire a linux dev input device(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,45679=>?@ACHMPSVX_`NkmonadA N! describes how to read and parse /;s from the binary data-stream provided by the device-file. qkmonadSize of 1 input event in bytes rkmonad'Function to convert bytestring to event skmonad5Perform an IOCTL operation on an open keyboard handle tkmonad)Configurable components of a DeviceSource ukmonadPath to the event-file vkmonad The method used to decode events wkmonad1Default configuration for parsing keyboard eventsPkmonad<The KeyEventParser that works on my 64-bit Linux environment xkmonad?Collection of data used to read from linux input.h event stream ykmonadConfiguration settings zkmonad'Posix filedescriptor to the device file {kmonad!Haskell handle to the device fileSkmonadOpen a device fileTkmonad:Open a device file on a standard linux 64 bit architecture |kmonad6Open the keyboard, perform an ioctl grab and return a  x. This can throw an 2 if the file cannot be opened for reading, or an  }2 if an ioctl grab could not be properly performed. ~kmonadERelease the ioctl grab and close the device file. This can throw an ? if the handle to the device cannot be properly closed, or an  6 if the ioctl release could not be properly performed. kmonadWRead a bytestring from an open filehandle and return a parsed event. This can throw a   if reading from the  x/ fails to yield a parseable sequence of bytes. skmonad'Descriptor to open keyboard file (like devinput/eventXX)kmonadTrue to grab, False to ungrabkmonadReturn the exit codeSkmonad-The method by which to read and decode eventskmonadThe filepath to the device fileTkmonadThe filepath to the device file |kmonad$The method by which to decode eventskmonadThe path to the device fileNPSTSTNPCollection of basic operations(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`'XkmonadqThe packet used to trigger a KeyFun, containing info about the event and how long since the Hook was registered.Zkmonad&Time elapsed since hook was registered[kmonad"The key event triggering this call\kmonadCBoolean isomorph signalling wether an event should be caught or notckmonadA c= value describes how long to wait and what to do upon timeoutekmonad(Delay before timeout action is triggeredfkmonadAction to perform upon timeoutgkmonad&ADT signalling where to install a hookhkmonad/Install the hook immediately after receiving a ikmonad(Install the hook just before emitting a qkmonadThe content for 1 key hookskmonadOptional timeout machinerytkmonad!The function to call on the next zkmonad$A newtype wrapper used to construct ~ actions}kmonad:Type alias for `any monad that can perform MonadK actions`~kmonad\ contains the additional bindings that get added when we are currently processing a button.kmonad7Access the keycode to which the current button is boundkmonad~ contains all the operations used to constitute button actions. It encapsulates all the side-effects required to get everything running.kmonadEmit a KeyEvent to the OSkmonad+Pause the current thread for n millisecondskmonad!Pause or unpause event processingkmonadRegister a callback hookkmonadRun a layer-stack manipulationkmonad"Insert an event in the input queuekmonadRun a shell-commandkmonadG describes all the different layer-manipulations that KMonad supports.kmonad#Add a layer to the top of the stackkmonad%Remove the first occurence of a layerkmonadChange the base-layerkmonadGCreate a KeyEvent matching pressing or releasing of the current button.kmonad(Register a simple hook without a timeoutkmonadRegister a hook with a timeoutkmonad4Perform an action after a period of time has elapsedVThis is essentially just a way to perform async actions using the KMonad hook system.kmonadPerform an action immediately after the current action is finished. NOTE: there is no guarantee that another event doesn't outrace this, only that it will happen as soon as the CPU gets to it.kmonadICreate a KeyPred that matches the Press or Release of the current button.kmonadAWait for an event to match a predicate and then execute an actionkmonadFExecute an action on the detection of the Switch of the active button.kmonadzTry to call a function on a succesful match of a predicate within a certain time period. On a timeout, perform an action.kmonadLike ;, but acquires a hold when starting, and releases when donekmonadWhere to install the hookkmonadThe timeout delay for the hookkmonad The action to perform on timeoutkmonad The action to perform on triggerkmonadThe resulting actionkmonad+The time within which this filter is activekmonad"The predicate used to find a matchkmonadThe action to call on timeoutkmonad'The action to call on a succesful matchkmonadThe resulting actionkmonad+The time within which this filter is activekmonad"The predicate used to find a matchkmonadThe action to call on timeoutkmonad'The action to call on a succesful matchkmonadThe resulting action;XYZ[\]^cdefghijmlkqrstuvxwz{|}~;\]^XYZ[cdefghiqrstuvxwjmlk~}z{|How buttons work(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`kmonadA  consists of two ~h actions, one to take when a press is registered from the OS, and another when a release is registered. kmonadAction to take when pressed kmonadAction to take when releasedkmonad Create a " out of a press and release action NOTE: Since } is an existentially qualified ~L, the monadic actions specified must be runnable by all implementations of ~5, and therefore can only rely on functionality from ~!. I.e. the actions must be pure ~.kmonad Create a new button with only a  action kmonad:Perform both the press and release of a button immediately kmonadGPerform the press action of a Button and register its release callback.'This performs the action stored in the 7 field and registers a callback that will trigger the  when the release is detected.kmonadTA button that emits a Press of a keycode when pressed, and a release when released.kmonad)Create a new button that first presses a 0 before running an inner button, releasing the  again after the inner  is released.kmonad/Create a button that toggles a layer on and offkmonad7Create a button that switches the base-layer on a presskmonad,Create a button that adds a layer on a presskmonadCCreate a button that removes the top instance of a layer on a presskmonad:Create a button that does nothing (but captures the input)kmonad6Create a button that executes a shell command on presskmonadCreate a new button from 2 buttons, an inner and an outer. When the new button is pressed, first the outer is pressed, then the inner. On release, the inner is released first, and then the outer.kmonadA @ that, once pressed, will surround the next button with another.Think of this as, essentially, a tappable mod. For example, an 'aroundNext KeyCtrl' would, once tapped, then make the next keypress C- whatever.kmonadjCreate a new button that performs both a press and release of the input button on just a press or releasekmonad Create a  that performs a tap of one button if it is released within an interval. If the interval is exceeded, press the other button (and release it when a release is detected).kmonad Create a  that performs a tap of 1 button if the next event is its own release, or else switches to holding some other button if the next event is a different keypress.kmonadLike 5, except that after some interval it switches anywayskmonad>Create a tap-hold style button that makes its decision based on the next detected release in the following manner: 1. It is the release of this button: We are tapping 2. It is of some other button that was pressed *before* this one, ignore. 3. It is of some other button that was pressed *after* this one, we hold.sIt does all of this while holding processing of other buttons, so time will get rolled back like a TapHold button.kmonad>Create a tap-hold style button that makes its decision based on the next detected release in the following manner: 1. It is the release of this button: We are tapping 2. It is of some other button that was pressed *before* this one, ignore. 3. It is of some other button that was pressed *after* this one, we hold.QIf we encounter the timeout before any other release, we switch to holding mode.sIt does all of this while holding processing of other buttons, so time will get rolled back like a TapHold button.kmonad Create a & that contains a number of delays and s. As long as the next press is registered before the timeout, the multiTap descends into its list. The moment a delay is exceeded or immediately upon reaching the last button, that button is pressed.kmonad Create a { that performs a series of taps on press. Note that the last button is only released when the tapMacro itself is released.kmonadFSwitch to a layer for a period of time, then automatically switch backkmonadISwitch to a layer for the next button-press and switch back automaically.1NOTE: liable to change, this is essentially just  and  combined.kmonadThe " to `wrap around` the inner buttonkmonad(The button to nest inside `being modded`kmonad The outer kmonad The inner kmonadThe resulting nested kmonad The outer kmonadThe resulting kmonadWhich  should trigger the tapkmonadThe  to tapkmonad The tapping )The basic types of configuration parsing.(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code)None,4567=>?@ACHMPSVX_`%*kmonadThe / contains all the data needed to construct an .kmonadHow to grab the source keyboardkmonad"How to construct the out keybboardkmonadAn  of  actionskmonadName of initial layerkmonad!How to deal with unhandled eventskmonadWhether to allow shell commandskmonad Button ADTkmonadReference a named buttonkmonadEmit a keycodekmonadToggle to a layer when heldkmonadSwitch base-layer when pressedkmonadAdd a layer when pressedkmonad+Remove top instance of a layer when pressedkmonadDo 2 things based on behaviorkmonad'Do 2 things based on behavior and delaykmonad%Mixture between KTapNext and KTapHoldkmonadDo 2 things based on behaviorkmonad'Like KTapNextRelease but with a timeoutkmonadSurround a future buttonkmonad Do things depending on tap-countkmonadWrap 1 button around anotherkmonadSequence of buttons to tapkmonadCompose-key sequencekmonadPause for a period of timekmonad&Switch to a layer for a period of timekmonad&Perform next button in different layerkmonadExecute a shell commandkmonad$Transparent button that does nothingkmonadButton that catches eventkmonad5The type of errors returned by the Megaparsec parserskmonad+Parser's operate on Text and carry no statekmonadAll possible single settingskmonad+All different output-tokens KMonad can takekmonad*All different input-tokens KMonad can takekmonadA layer of buttonskmonad)A unique name used to refer to this layerkmonadA list of button tokenskmonad%A mapping from names to button tokenskmonadBA list of keycodes describing the ordering of all the other layerskmonad/Any statement in a config-file must parse to a kmonadA list of different  values a                             ! " # $ % & ' ( ) * + , - . / 0 1       K       *How to turn a text-file into config-tokens(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code)None,4567=>?@ACHMPSVX_`E! kmonadTry to parse a list of  from { kmonad<Load a set of tokens from file, throw an error on parse-fail 2kmonadConsume whitespace 3kmonad,Consume whitespace after the provided parser 4kmonadConsume 1 symbol 5kmonadList of all characters that end a word or sequence 6kmonad-Consume all chars until a space is encounterd 7kmonadCRun the parser IFF it is followed by a space, eof, or reserved char 8kmonad8Run the parser IFF it is not followed by a space or eof. 9kmonadJCreate a parser that matches symbols to values and only consumes on match. :kmonad*Run a parser between 2 sets of parentheses ;kmonadARun a parser between 2 sets of parentheses starting with a symbol <kmonad%Run a parser that parser a bool value =kmonadParse a keycode >kmonadParse an integer ?kmonad-Parse text with escaped characters between "s @kmonadParse a variable reference Akmonad2Consume an entire file of expressions and comments BkmonadParse 0 or more KExpr's Ckmonad Parse 1 KExpr Dkmonad7Different ways to refer to shifted versions of keycodes EkmonadNames for various buttons Fkmonad"Parse "X-b" style modded-sequences Gkmonad'Parse Pxxx as pauses (useful in macros) Hkmonad#()-syntax tap-macro IkmonadCompose-key sequence JkmonadParse a dead-key sequence as a O followed by some symbol KkmonadParse any button LkmonadParse an input token MkmonadParse an output token NkmonadParse the DefCfg token OkmonadIAll possible configuration options that can be passed in the defcfg block Pkmonad'Parse a collection of names and buttons  +The code that turns tokens into a DaemonCfg(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code)None,4567=>?@ACHMPSVX_`f QkmonadJoining Config RkmonadHow to prefix compose-sequences Skmonad#The source expresions we operate on Tkmonad7All the things that can go wrong with a joining attempt Ukmonad/Monad in which we join, just Except over Reader VkmonadPerform a joining computation kmonadGTurn a list of KExpr into a CfgToken, throwing errors when encountered.NOTE: We start joinConfig with the default JCfg, but joinConfig might locally override settings by things it reads from the config itself. Wkmonad8Extract anything matching a particular prism from a list Xkmonad<Take the head of a list, or else throw the appropriate error YkmonadCTake the one and only block matching the prism from the expressions kmonad7Update the JCfg and then run the entire joining process ZkmonadJoin an entire  from the current list of . [kmonadEReturn a JCfg with all settings from defcfg applied to the env's JCfg \kmonadTurn a q,-only RIO into a function from LogFunc to IO ]kmonad&Extract the KeySource-loader from the s ^kmonad$Extract the KeySource-loader from a s _kmonadExtract the fallthrough setting `kmonadExtract the fallthrough setting akmonad7The Linux correspondence between IToken and actual code bkmonad7The Linux correspondence between OToken and actual code ckmonad-Build up a hashmap of text to button mappings6Aliases can refer back to buttons that occured before. dkmonadTurn T]s (caused by joining a KTrans) into the appropriate error. KTrans buttons may only occur in  definitions. ekmonad*Turn a button token into an actual KMonad  value fkmonad{Join the defsrc, defalias, and deflayer layers into a Keymap of buttons and the name signifying the initial layer to load. gkmonadCheck and join 1 deflayer. gkmonadMapping of names to buttonskmonadList of valid layer nameskmonadLayout of the source layerkmonadThe layer token to joinkmonadThe resulting tuple    Component for handling hooks(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`z kmonadThe  \ environment that is required for keeping track of all the different targets and callbacks. hkmonadWhere we get our events from ikmonadUsed to signal timeouts jkmonadStore of hooks kkmonad Create a new  8 environment which reads events from the provided action kmonad Create a new   environment, but as a  monad to avoid nesting lkmonadNConvert a hook in some UnliftIO monad into an IO version, to store it in Hooks kmonad:Insert a hook, along with the current time, into the store mkmonad+Cancel a hook by removing it from the store nkmonadCRun the function stored in a Hook on the event and the elapsed time okmonad6Run all hooks on the current event and reset the store pkmonadPull 1 event from the  h. If that action is not caught by any callback, then return it (otherwise return Nothing). At the same time, keep reading the timer-cancellation inject point and handle any cancellation as it comes up. kmonad4Keep stepping until we succesfully get an unhandled  pkmonadThe   environmentkmonad-An action that returns perhaps the next event        Implementation details behind (c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`Z kmonadThe configuration of a 7 with some additional state to keep track of the last  kmonad!The configuration for this button kmonadThe  to which this button is bound !kmonad(State to keep track of last manipulation 'kmonad Initialize a  ?, note that a key is always initialized in an unpressed state. (kmonadTry to switch a  ". This only does something if the  is different from the  &T field. I.e. pressing a pressed button or releasing a released button does nothing.    ! " $ & # % ' (    ! " $ & # % ' (7Implementation of mapping key-presses to button actions(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_`v +kmonadThe  +* environment containing the current keymapNOTE: Since the  +I will never have to deal with anything asynchronously we can simply use s here. qkmonad Create a  + from a  + of uninitialized =s and a tag indicating which layer should start as the base. ,kmonad Create a  + but do so in the context of a  monad to ease nesting. rkmonadDPrint a header message followed by an enumeration of the layer-stack -kmonad%Perform operations on the layer-stack .kmonad Lookup the  # currently mapped to the key press. qkmonadThe initial base layerkmonadThe keymap of s -kmonadThe  + environmentkmonadThe  to performkmonadThe resulting action .kmonadThe  + to lookup inkmonadThe  to lookupkmonadThe resulting action + , - . + , - .The central app-loop of KMonad(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportableNone,4567=>?@ACHMPSVX_` 0kmonadPRecord of all the configuration options required to run KMonad's core App loop. 2kmonadHow to open a * 3kmonadHow to open a ) 4kmonadThe map defining the  layout 5kmonadActive layer when KMonad starts 6kmonad0Whether uncaught events should be emitted or not 7kmonad"Whether shell-commands are allowed skmonad(Environment of a running KMonad app-loop tkmonad/The complete environment capable of satisfying ~ ukmonad1The app environment containing all the components vkmonad6The environment describing the currently active button wkmonad4Initialize all the components of the KMonad app-loopNOTE: This is written in u over our normal RIO monad. This is just to to simplify a bunch of nesting of calls. At no point do we make use of  or other  functionality. xkmonad8Trigger the button-action press currently registered to  ykmonad#Perform 1 step of KMonad's app loopeWe forever: 1. Pull from the pull-chain until an unhandled event reaches us. 2. If that event is a ( we use our keymap to trigger an action. Akmonad+Run KMonad using the provided configuration Fkmonad,Hook up all the components to the different ~ functionalities 0 1 2 3 4 5 6 7 8 9 = > < ? ; : A 0 1 2 3 4 5 6 7 8 9 = > < ? ; : A6How to parse arguments and config files into an AppCfg(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code)None,4567=>?@ACHMPSVX_` Lkmonad Run KMonad zkmonadExecute the provided  Construct the log-funcParse the config-fileMaybe start KMonad {kmonad"Parse a configuration file into a  0 record L L | !"#"$%&%'()*+,-,./01213,456789:;<=>/?/@/A/BCDEFGHIJKLMNMO1PQR/S/TUVWX,Y1Z[\/]Q^/_`abc9d=efghijklmnopoqorosotuvuwuxuyz{|}~o/ooooooo`VVVVVVVVVVVVVVCCCCCCCCCCCCCCiiiiii;;;;     gggggggggggggggg g!g"g#g$g%g&g'g(g)*+*,-./012345464678789:9;<=<>?@?A?B?C?DEFQGQHQIQJQKQLQMQNQOQPQQQRQSQTQUQVQWQXQYQZQ[Q\Q]Q^Q_Q`QaQbQcQdQeQfghi/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/{/|M}M~M""""""""""%%,,,,, 1111111111      !"#$%&'()*+,-./0/1/2/3/4/567689:9;9<9=9>9?9@9A9B9C9D9E9FGHGIJKJLJMJNJOJPJQJRJSJTJUJVJWJXJYJZJ[J\J]J^J_J`JaJbJcJdJeJfJgJhJiJjJkJlJmJnJoJpJqJrJsJtJuJvwxwywzw{w|w}~~~~~~~~~~~~~~~~~~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 67879:;:<:=:>:?:@:A:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:\:]:^:_:`:a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z:{:|:}:~:::::             !"#$%&'()*+,-.-/-0-1-2-3-4-5-6-7-8-9-:-;-<-=->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-fghgigjgkglgmgngogpgqgrgsgtgugvgwgxgygzg{g|g}g~gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg                        (  ,    0     4 ! " # $   % " % & ' ( ) * + , - . / 0 1 2 3 4567879:;<=>?>@ABACACADAEAFAFAGHIHIHJKLKMKNKOKPKQKRKSKTKUKVKVWXWYWZW[\]^\]_`ab`ac`ad`aefghijikilmnopoqrsrsrtrurvrwrxryrzr{||}~      !"#$%&'()*+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;<=<><?<@ABACADAEAFAGAHAIAJAKALAMANAOPQPRPSPTUVWXYZ[\\]^_`a_`b_`c_`d_`e_`f_`g_`h_`i_`j_kl_km_kn_ko_kp_kq_kr_ks_kt_ku_kv_kw_xy_xz_x{_x|_x}_x~_x_x_x_x_x____________      !"#$%&'()*)+),)-).)/)0)1)2)3)45657589:9;9<9=9>9?9@9@9A9B9CDEFEGEHEIEJKLKMKNKOPQPRPSPTUVUWXYYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                V               ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q q r s t u v w x y z { | } ~                                                                        !                                                                                            ! "  ! #  ! $  ! %  ! &  ! '  ! (  ! )  ! *  ! +  ! ,  ! -  ! .  ! /  ! 0  ! 1  ! 2  ! 3  ! 4 5 6 7 5 6 8 5 6 9 5 6 : 5 6 ; 5 6 < 5 6 = 5 6 > 5 6 ? 5 6 @ 5 6 A 5 6 B 5 6 C 5 6 D 5 6 E 5 6 F 5 6 G 5 6 H 5 6 I 5 6 J 5 6 K 5 6 L 5 6 M 5 6 N 5 6 O 5 6 P 5 6 Q 5 6 R 5 S T 5 S U 5 V W 5 V X 5 V Y 5 V Z 5 V [ 5 V \ 5 V ] 5 V ^ 5 V _ 5 V ` 5 V a 5 V 5 V b 5 V c 5 V d 5 V e 5 V f 5 V g 5 V h 5 V i 5 V j 5 V k 5 V l 5 V m 5 V n 5 V o 5 V p 5 V q 5 V r 5 V s 5 V t 5 V u 5 V v 5 w x 5 y z 5 y 5 y { 5 y | 5 y } 5 y ~ 5 y  5 y 5 y 5 y 5 y 5 y 5 y 5 y 5 y 5 y 5 y 5 5 5 5 5 5 5 5  5  5  5  5  5  5  5  5  5  5 5 5  5 5 5  5  5  5 5 5 5 5 5 5 5 5 5 5 5 5  5  5 5 5 5 5  5  5 5 5 5 5 5 5 5 5 5 5 5  5  5  5  5  5 5 5 5  5  5                                                                            kmonad-0.4.1-inplaceKMonad.PreludeKMonad.Keyboard.ComposeSeqKMonad.Args.Cmd Data.MultiMapKMonad.Keyboard.KeycodeData.LayerStackKMonad.KeyboardKMonad.App.SluiceKMonad.App.Dispatch KMonad.UtilKMonad.Keyboard.IOKMonad.Keyboard.IO.Linux.Types#KMonad.Keyboard.IO.Linux.UinputSink%KMonad.Keyboard.IO.Linux.DeviceSource KMonad.Action KMonad.ButtonKMonad.Args.TypesKMonad.Args.ParserKMonad.Args.JoinerKMonad.App.HooksKMonad.App.BEnvKMonad.App.Keymap KMonad.App KMonad.ArgsAppDispatchAppCfgbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip Data.Tuplefstsnd otherwiseassertmap$GHC.Num fromInteger-GHC.Real fromRational GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail Control.Arrowfirst Data.String fromString fromIntegral realToFrac toInteger toRational Control.Monadguard<>memptymappendmconcatjoin<*>pure*>GHC.EnumBoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataDataFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeable MonadFailIsString Applicative Data.FoldableFoldableData.Traversable Traversable GHC.GenericsGeneric SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64integer-wired-inGHC.Integer.TypeInteger GHC.NaturalNatural GHC.MaybeMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEitherGHC.Stack.Types CallStackFalseNothingJustTrueLeftRightLTEQGTliftMideitherData.Functor.Contravariant contramap Contravariant mtl-2.2.2Control.Monad.Reader.Class MonadReaderasklocalGHC.IO.Handle.FDstdoutStringshowGHC.IO.Handle.TypesHandleGHC.STST GHC.Conc.SyncThreadId"async-2.2.2-9roCKOC3ShkBtv3iqrylfJControl.Concurrent.Async waitBothSTMwaitEitherSTM_ waitEitherSTMwaitEitherCatchSTM waitAnySTMwaitAnyCatchSTMpollSTM waitCatchSTMwaitSTM asyncThreadIdAsync>$ Data.VoidabsurdVoidgmapMogmapMpgmapMgmapQigmapQgmapQrgmapQlgmapT dataCast2 dataCast1 dataTypeOftoConstrgunfoldgfoldlControl.Concurrent.ChanChanData.Bifunctorbimap BifunctorControl.Monad.IO.ClassliftIOMonadIOmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforMforsequencemapM sequenceAtraverseControl.Applicativeoptional&&&***secondArrowData.Functor.Identity runIdentityIdentitystderrstdin writeTVarreadTVarnewTVarorElseSTMTVarGHC.IO.ExceptionSomeAsyncException ExitFailure ExitSuccessExitCodeBlockBuffering LineBuffering NoBuffering BufferMode GHC.IO.DeviceSeekMode GHC.IORefIORefGHC.IOFilePath IOExceptionGHC.Exception.Type SomeExceptiondisplayException fromException toException ExceptionData.Functor.ConstgetConstConstnotElemallanyorand concatMapconcatmsumasum sequence_ sequenceA_forM_mapM_for_ traverse_productsumelemlengthnulltoListfoldl'foldrfoldMapfold Data.OldListunwordswords Text.Read readMaybeisRightisLeftpartitionEithersrightsleftsData.Ord comparingDown Data.ProxyProxyControl.Category>>>CategoryData.Type.EqualityRefl:~: GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModeForeign.StorableStorableatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogexppiatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadix byteSwap64 byteSwap32 byteSwap16lcmgcd^^^oddevendivModquotRemmoddivremquotrecip/floorceilingroundtruncateproperFractionmaxBoundminBoundfromEnumrunSTzipWithlookupreversebreakspandroptake dropWhile takeWhile replicate Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybe Data.Boolbool Data.Function&onfix Data.Functorvoid$><&><$>uncurrycurryGHC.MVarMVarsubtractsignumabs*+asTypeOf$!flip.constapliftM5liftM4liftM3liftM2when=<<liftA3liftA<$<*liftA2<|> Alternativemplusmzero MonadPlus:|NonEmptyGHC.Err undefinederror HasCallStackcompare<<=>maxmin/=&&||notbytestring-0.10.10.0Data.ByteString.Short.Internal fromShortShortByteStringData.ByteString.Internal ByteString Data.ByteString.Builder.InternalBuildertoShort text-1.2.4.0Data.Text.InternalTextcontainers-0.6.2.1Data.IntMap.InternalIntMapData.IntSet.InternalIntSetData.Map.InternalMapData.Sequence.InternalSeqData.Set.InternalSetdeepseq-1.4.4.0Control.DeepSeqforce$!!deepseqrnfNFData(exceptions-0.10.4-GoLzzqEbo2sHmTCS8ff5IMControl.Monad.CatchthrowM MonadThrowtransformers-0.5.6.2Control.Monad.Trans.Classlift'hashable-1.3.0.0-2bg86qF31rr5MmQh3YIjb8Data.Hashable.ClassHashable(profunctors-5.5.2-CCbvAPZjdQKKsJ1Wa7ZysCData.Profunctor.Unsafe Profunctor4unordered-containers-0.2.10.0-3nryNlWurxz2Zvr1y2LTL6Data.HashMap.BaseHashMap&vector-0.12.1.2-C2W44iPdAFeHo4yLU081GdData.Vector.Unboxed.BaseUnboxData.HashSet.BaseHashSet Data.VectorVectorControl.Monad.Trans.ReaderReader!lens-4.18.1-G8UlJmxdb68rW0LxmoSCnControl.Lens.THdefaultFieldRulesmakeFieldsNoPrefix makeFieldsabbreviatedNamerabbreviatedFieldsclassUnderscoreNoPrefixNamerclassUnderscoreNoPrefixFieldscamelCaseNamercamelCaseFieldsunderscoreNamerunderscoreFields makeWrappeddeclareLensesWith declareFieldsdeclareWrapped declarePrismsdeclareClassyFor declareClassydeclareLensesFor declareLensesmakeLensesWith makeClassyFor makeLensesFor makeClassy_ makeClassy makeLenses classyRules_ classyRules mappingNamerlookingupNamer lensRulesForunderscoreNoPrefixNamer lensRules lensClass lensField createClassgenerateLazyPatternsgenerateUpdateableOpticsgenerateSignatures simpleLensesControl.Lens.Internal.FieldTH LensRules FieldNamer MethodNameTopNameDefName ClassyNamerControl.Lens.Internal.PrismTHmakeClassyPrisms makePrismsControl.Lens.AtiatsansixAtiix icontainsIndexcontainsContainsIxValueixIxedatAtControl.Lens.EacheachEachControl.Lens.Platedgplate1gplateparts composOpFoldparaparaOf holesOnOfholesOnholes contextsOnOf contextsOn contextsOfcontextstransformMOnOf transformMOf transformMOn transformM transformOnOf transformOf transformOn transform cosmosOnOfcosmosOncosmosOfcosmos universeOnOf universeOn universeOfuniverse rewriteMOnOf rewriteMOn rewriteMOfrewriteM rewriteOnOf rewriteOn rewriteOfrewritechildrendeep...platePlatedGPlatedGPlated1Control.Lens.ZoomZoomed MagnifiedzoomZoommagnifyMagnifyControl.Lens.Wrappedalafala _Unwrapping _Wrapping _Unwrapping' _Wrapping'op _Unwrapped_Wrapped _Unwrapped' _GWrapped'Wrapped Unwrapped _Wrapped' Rewrapped RewrappingControl.Lens.Consunsnocsnoc|>_last_init_tail_headunconscons<|:<:>_ConsCons_SnocSnocControl.Lens.EmptyEmpty_EmptyAsEmptyControl.Lens.Isocoerced secondingfirsting bimappingrmappinglmapping dimapping contramappingimagmamagma involutedreversedlazyflipped uncurriedcurriedanonnon'nonmappingenumunderxplatfxplataufaucloneIsowithIsofromisoStrictLazySwappedReversedListAnIsoAnIso'swappedstrictControl.Lens.Equality withEquality fromLeibniz' fromLeibniz underEquality overEquality equality'equality cloneEqualitysimplesimplyfromEqmapEqsubstEqrunEq Identical AnEquality AnEquality'Control.Lens.Indexed itraverseByOf itraverseBy ifoldMapByOf ifoldMapBy imapAccumL imapAccumRiforMimapMiforitoListifoldlMifoldrMifind iconcatMapiforM_imapM_ifor_ itraverse_noneinoneiallianyindexindicesicompose<.> reindexed selfIndex.><.imappedimapFunctorWithIndexifoldl'ifoldr'ifoldlifoldrifoldedifoldMapFoldableWithIndex itraversed itraverseTraversableWithIndexControl.Lens.ReifiedrunLensLens ReifiedLens ReifiedLens'runIndexedLens IndexedLensReifiedIndexedLensReifiedIndexedLens'runIndexedTraversalIndexedTraversalReifiedIndexedTraversalReifiedIndexedTraversal' runTraversal TraversalReifiedTraversalReifiedTraversal' runGetterGetter ReifiedGetterrunIndexedGetter IndexedGetterReifiedIndexedGetterrunFoldFold ReifiedFoldrunIndexedFold IndexedFoldReifiedIndexedFold runSetterSetter ReifiedSetterReifiedSetter'runIndexedSetter IndexedSetterReifiedIndexedSetterReifiedIndexedSetter'runIsoIso ReifiedIso ReifiedIso'runPrismPrism ReifiedPrism ReifiedPrism'Control.Lens.LevelilevelslevelsControl.Lens.Traversal sequenceByOf traverseByOf confusingdeepOffailing ifailoverfailoverelements elementsOfelement elementOfignored traversed64 traversed1 traversed imapAccumLOf imapAccumROfiforMOfimapMOfiforOf itraverseOfcloneIndexedTraversal1cloneIndexPreservingTraversal1cloneTraversal1cloneIndexedTraversalcloneIndexPreservingTraversalcloneTraversaldroppingtakingbesideboth1bothholes1OfholesOfunsafeSingularsingulariunsafePartsOf'unsafePartsOf'iunsafePartsOf unsafePartsOf ipartsOf'partsOf'ipartsOfpartsOfilocilociscanl1Ofscanr1Of mapAccumLOf mapAccumROf transposeOf sequenceOfforMOfmapMOf sequenceAOfforOf traverseOf ATraversal ATraversal' ATraversal1 ATraversal1'AnIndexedTraversalAnIndexedTraversal1AnIndexedTraversal'AnIndexedTraversal1' Traversing Traversing1 Traversing' Traversing1' traverseMin TraverseMin traverseMax TraverseMaxControl.Lens.Fold foldMapByOffoldByOfidroppingWhile itakingWhile ifiltered findIndicesOf findIndexOf elemIndicesOf elemIndexOf^@?!^@?^@.. itoListOf ifoldlMOf ifoldrMOf ifoldlOf' ifoldrOf'ifindMOfifindOf iconcatMapOfiforMOf_imapMOf_iforOf_ itraverseOf_inoneOfiallOfianyOfifoldlOfifoldrOf ifoldMapOf backwardsipreusespreusesipreusepreuse ipreviewspreviewsipreviewpreviewipreprehasn'thasfoldlMOffoldrMOf foldl1Of' foldr1Of'foldlOf'foldrOf'foldl1Offoldr1OflookupOffindMOffindOf minimumByOf maximumByOf minimum1Of minimumOf maximum1Of maximumOf notNullOfnullOflast1OflastOffirst1OffirstOf^?!^?lengthOfconcatOf concatMapOf notElemOfelemOfmsumOfasumOf sequenceOf_forMOf_mapMOf_ sequence1Of_for1Of_ traverse1Of_ sequenceAOf_forOf_ traverseOf_sumOf productOfnoneOfallOfanyOforOfandOf^.. toNonEmptyOftoListOffoldlOffoldrOffoldOf foldMapOflinedworded droppingWhile takingWhile filteredByfilterediteratedunfoldedcycled replicatedrepeatedfolded64folded ifoldringfoldringifoldingfoldingControl.Lens.Prism_Shownearlyonly_Void_Nothing_Just_Right_Leftmatchingisn'tbelowasidewithoutoutsideprism'prism clonePrism withPrismAPrismAPrism'Control.Lens.Reviewreusesreusereviews#reviewreununtoControl.Lens.Gettergetting^@.iusesiuseiviewsiview ilistenings listenings ilistening listeningusesuse^.viewsviewilikelikeitotoGettingIndexedGetting AccessingControl.Lens.Tuple_19'_18'_17'_16'_15'_14'_13'_12'_11'_10'_9'_8'_7'_6'_5'_4'_3'_2'_1'_1Field1_2Field2_3Field3_4Field4_5Field5_6Field6_7Field7_8Field8_9Field9_10Field10_11Field11_12Field12_13Field13_14Field14_15Field15_16Field16_17Field17_18Field18_19Field19Control.Lens.Lensfusinglast1head1uniteddevoid<#=<#~#%%=<#%=<#%~#%=#=#%%~#%~#~storing^#<<%@=<%@=%%@=%%@~<<%@~<%@~overA<<>=<<>~<<~<<<>=<<&&=<<||=<<**=<<^^=<<^=<~<<&&~<<||~<<**~<<^^~<<^~<=<>~chunkoneOf anySingleBut anySinglesatisfysingleregisterFancyFailureregisterFailureregisterParseErrorregion customFailure unexpected fancyFailurefailure runParserT' runParserT runParser' runParser parseTest parseMaybeparseParsecText.Megaparsec.InternalParsecTText.Megaparsec.Class MonadParseceof lookAheadlabel parseErrorhidden notFollowedBy withRecovery observingtokentokens takeWhileP takeWhile1PtakePgetParserStateupdateParserStateText.Megaparsec.ErrorparseErrorTextPrettyparseErrorPrettyerrorBundlePrettyattachSourcePossetErrorOffset errorOffset mapParseError ErrorItemTokensLabel EndOfInput ErrorFancy ErrorFailErrorIndentation ErrorCustomParseErrorBundle bundleErrorsbundlePosStateShowErrorComponentshowErrorComponenterrorComponentLenText.Megaparsec.StreamTokenStream tokenToChunk tokensToChunk chunkToTokens chunkLength chunkEmptytake1_takeN_ takeWhile_ showTokens tokensLength reachOffsetreachOffsetNoLineText.Megaparsec.StateState stateInput stateOffset statePosStatestateParseErrorsPosState pstateInput pstateOffsetpstateSourcePospstateTabWidthpstateLinePrefixText.Megaparsec.PossourcePosPretty initialPosdefaultTabWidthpos1unPosmkPosPosInvalidPosException SourcePos sourceLine sourceColumn sourceName ParseError TrivialError FancyErrorsclexemesymbol terminatorsword terminatedprefix fromNamedparen statementkeycodePnumPtextPderefPconfigPexprsPexprP shiftedNames buttonNamesmoddedPpauseP rmTapMacroP composeSeqP deadkeySeqPbuttonPitokenPotokenPdefcfgPsettingP defaliasPJCfg_cmpKey_kes JoinErrorJrunJextractonlyOneoneBlock joinConfig' getOverriderunLFgetIgetOgetFTgetAllow pickInput pickOutput joinAliasesunnest joinButton joinKeymap joinLayer _injectTmr_hooksmkHooks'ioHook cancelHookrunEntryrunHooks mkKeymap' debugReportAppEnvKEnv_kAppEnv_kBEnv initAppEnvpressKeylooprunCmd loadConfig