!ki      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc d e fghij k l m n o p q r s tuvwxyz { | }~        !"#$%&'()*+,-./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&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){)|)})~))))))))))))))))))))))))))))))))))))))))))))))))))))))))))*********++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---.......////////// / / / / ///////////00000000 0!0"0#0$0%0&0'0(0)0*0+0,0-1.1/101112232425262728293:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L3M3N3O3P3Q3R3S3T3U3V3WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{4|4}4~4444444445555555555555555566666666666666667777777777777777777777777777777777777777777777777788888888888999999999999999:::::::::: : : : : ::::::::::;;;;;;;;; ;!;";#;$;%;&;'<(=)=*=+=,=-=.=/=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@f@g@h@i@j@k@lAmnopqrstuvwxyz{|}~FBSafeVY&yi-coreRExecute IO (Maybe a) action replacing all exceptions with return value of Nothing.yi-core<Execute IO () action, replacing all exceptions with messagesyi-core<Execute IO () action, replacing all exceptions with messagesCSafeZyi-coreKSubtraction, but treat maxBound as infinity. i.e. maxBound -? x == maxBoundSafe &'3QSTVe yi-coreParser process=yi-coreParser specificationyi-coreJCompute the combination of two profiles, as well as which one is the best.yi-core<Right-eval a fully defined process (ie. one that has no Sus)yi-coreIntelligent, caching best.yi-coreLPush a chunk of symbols or eof in the process. This forces some suspensions.Hyi-corePush some symbols.Iyi-corePush eofJyi-coreMake a parser into a process.Kyi-coreARun a process (in case you do not need the incremental interface)Nyi-coreParse the same thing as the argument, but will be used only as backup. ie, it will be used only if disjuncted with a failing parser.3456789:;<=>@?ABCDEFGHIJKLMNOP3NCDMLKJAHIFOE=>@?BP456789:;<G  Safefb[\]^_`ab[\]^_`baDGPL-2yi-devel@googlegroups.com experimentalportableSafeoyi-core>Returns absolute name of the file, which doesn't contain any /./, /../, // sequences or symlinksyi-core/Dereferences symbolic links until regular file directorysomething_else appearsyi-coreMake a path absolute.yi-core,Combines two paths, moves up one level on ..yi-core(Splits path into parts by path separatorText version would look like EF (not . T.null) . T.split ( pathSeparators)But we should move to system-filepath package anyway. Safercyi-core!Canonicalize a user-friendly pathdyi-coreWTurn a user-friendly path into a computer-friendly path by expanding the leading tilda.eyi-core!Is a user-friendly path absolute?cdecdeGGPL-2yi-devel@googlegroups.com experimentalportableNone 16;<=CQVmyi-core2Mutation actions (also used the undo or redo list) For the undoredo, we use the dpartial checkpoint/ (Berlage, pg16) strategy to store just the components of the state that change.Note that the update direction is only a hint for moving the cursor (mainly for undo purposes); the insertions and deletions are always applied Forward.`Note that keeping the text does not cost much: we keep the updates in the undo list; if it's a Deletes it means we have just inserted the text in the buffer, so the update shares the data with the buffer. If it's an Insert" we have to keep the data any way.yi-core buffer textyi-coreMarks for this bufferyi-coresyntax highlighting stateyi-core/set of (non overlapping) visual overlay regionsyi-core9Lowest modified offset since last recomputation of syntaxyi-coreNew FBuffer filled from string.yi-coreWrite string into buffer.yi-coreWrite string into buffer.yi-coreuShift a mark position, supposing an update at a given point, by a given amount. Negative amount represent deletions.yi-core Point of EOFyi-coreReturn n Chars starting at i of the buffer.yi-core7TODO: This guy is a pretty big bottleneck and only one function uses it which in turn is only seldom used and most of the output is thrown away anyway. We could probably get away with never converting this to String here. The old implementation did so because it worked over ByteString but we don't have to.}yi-core"Create an "overlay" for the style sty between points s and eyi-core,Obtain a style-update for a specific overlayyi-core/Add a style "overlay" between the given points.yi-core#Remove a previously added "overlay"yi-core'Return style information for the range (i,j) Style information is derived from syntax highlighting, active overlays and current regexp. The returned list contains tuples (l,s,r)> where every tuple is to be interpreted as apply the style s from position l to r in the buffer. In each list, the strokes are guaranteed to be ordered and non-overlapping. The lists of strokes are ordered by decreasing priority: the 1st layer should be "painted" on top.yi-coreChecks if an Update is validyi-coreApply a valid updateyi-coreReverse the given updateyi-core3Line at the given point. (Lines are indexed from 1)yi-core;Point that starts the given line (Lines are indexed from 1)yi-corePoint that's at EOL. Notably, this puts you right before the newline character if one exists, and right at the end of the text if one does not.yi-core'Get begining of the line relatively to point.yi-corePReturn indices of all strings in buffer matching regex, inside the given region.yi-coreModify a mark value.yi-corecReturns the requested mark, creating a new mark with that name (at the supplied position) if neededyi-coreLine for which to grab EOL foryi-core4Point from which we take the line to find the EOL ofD#"!&+.fghijklmnopqrstyvwuxz{|} None%6 ~yi-core-A URList consists of an undo and a redo list.yi-core A new empty ~. Notice we must have a saved file point as this is when we assume we are opening the file so it is currently the same as the one on diskyi-coreAdd an action to the undo list. According to the restricted, linear undo model, if we add a command whilst the redo list is not empty, we will lose our redoable changes.yi-coreAdd a saved file point so that we can tell that the buffer has not been modified since the previous saved file point. Notice that we must be sure to remove the previous saved file points since they are now worthless.yi-core!This undoes one interaction step.yi-core This redoes one iteraction step.yi-coreCPrepare undo by moving one interaction point from undoes to redoes.yi-core4Remove an initial interactive point, if there is oneyi-core5Insert an initial interactive point, if there is noneyi-coreQRepeatedly undo actions, storing away the inverse operations in the redo list.yi-coreRun the undo-function fL on a swapped URList making it operate in a redo fashion instead of undo.yi-coreundoIsAtSavedFilePoint. True/ if the undo list is at a SavedFilePoint indicating that the buffer has not been modified since we last saved the file. Note: that an empty undo list does NOT mean that the buffer is not modified since the last save. Because we may have saved the file and then undone actions done before the save. ~ ~ GPL-2yi-devel@googlegroups.com experimentalportableNoneKNyi-core1A CompletionTree is a map of partial completions.Example:2fromList ["put","putStr","putStrLn","print","abc"]Gives the following tree:D/ "p" "abc" / "ut" "rint" / Str "" / Ln ""n(The empty strings are needed to denote the end of a word) (A CompletionTree is not limited to a binary tree)yi-coreThis function converts a list of completable elements to a CompletionTree It finds elements that share a common prefix and groups them.fromList . toList = idyi-core{The largest element of a non-empty structure with respect to the given comparison function, Nothing if there are multiple largest elements.yi-core.Complete as much as possible without guessing. Examples:/complete $ fromList ["put","putStrLn","putStr"]$("put", fromList ["","Str","StrLn"])5complete $ fromList ["put","putStr","putStrLn","abc"]0("", fromList ["put","putStr","putStrLn","abc"])yi-coreUpdate the CompletionTree with new information. An empty list means that there is no completion left. A [mempty] means that the end of a word is reached. Examples:&update (fromList ["put","putStr"]) "p"fromList ["ut","utStr"](update (fromList ["put","putStr"]) "put"fromList ["","Str"])update (fromList ["put","putStr"]) "putS"fromList ["tr"] update (fromList ["put"]) "find" fromList []update (fromList ["put"]) "put" fromList [""]yi-core3Converts a CompletionTree to a list of completions.toList . fromList = sort . nub Examples: toList mempty[]toList (fromList ["a"])["a"]toList (fromList ["a","a","a"])["a"]toList (fromList ["z","x","y"]) ["x","y","z"]yi-coreFor debugging purposes.Example::putStrLn $ pretty $ fromList ["put", "putStr", "putStrLn"]["put"[""|"Str"[""|"Ln"]]] Safe֕GPL-2yi-devel@googlegroups.com experimentalportableNone<]yi-coreQSet the file to which debugging output should be written. Though this is called initDebug. Debugging output is not created by default (i.e., if this function is never called.) The target file can not be changed, nor debugging disabled.yi-core>Outputs the given string before returning the second argument.yi-coreTraces x and returns y.yi-coreLike traceM, but returns ().Safe-yi-coreSMap an Event to a Char. This is used in the emacs keymap for Ctrl-Q and vim keymap insertSpecialCharNoneVs =>@?CDLMNNCDML=>@? GPL-2yi-devel@googlegroups.com experimentalportableNone&';=>?AKV8yi-core#Abstraction of the automaton state.yi-core'Operational representation of a processyi-coreInteractive process descriptionyi-core,Abstraction of monadic interactive processesyi-coreOutputs a result.yi-coreiConsumes and returns the next character. Fails if there is no input left, or outside the given bounds.yi-core)Just like '(<||)' but in prefix form. It s the second argument.yi-core9Convert a process description to an "executable" process.yi-corePush an event in the automatonyi-core(find all the writes that are accessible.yi-core+Parses and returns the specified character.yi-core9Parses and returns the specified list of events (lazily).yi-core+Combines all parsers in the specified list.yi-core option x p will either parse p or return x without consuming any input.3None6GPL-2yi-devel@googlegroups.com experimentalportableNoneyi-coreCFinish an atomic command, for the purpose of killring accumulation.yi-coreSPut some text in the killring. It's accumulated if the last command was a kill tooyi-corePush a string in the killring.yi-coreCSet the top of the killring. Never accumulate the previous content.yi-coreGet the top of the killring.        Safe%13CNQV&'yi-core3A 'Layout a' wrapped in a state monad for tracking (s. This type is not6 itself a monad, but should rather be thought of as a (-free version of the , type.yi-coreSame as lm, but with all )s d. See < for an example of its use.yi-core-Things with orientations which can be flippedyi-core4Used by the vty frontend to draw vertical separatorsyi-coreA general bounding boxyi-coreIFixed number of "main" windows on the left; stack of windows on the rightyi-coreTransposed version of yi-coreRTall windows, with arranged in a balanced binary tree with sliders in between themyi-coreCWide windows (windows placed on top of one another, equally spaced)yi-core?Tall windows (i.e. places windows side-by-side, equally spaced)yi-coreExistential wrapper for ,!yi-core5The type of layout managers. See the layout managers 9, = and ;" for some example implementations."yi-corebGiven the old layout and the new list of windows, construct a layout for the new list of windows.If the layout manager uses sliding dividers, then a user will expect that most of these dividers don't move when adding a new window. It is the layout manager's responsibility to ensure that this is the case, and this is the purpose of the Layout a argument.oThe old layout may come from a different layout manager, in which case the layout manager is free to ignore it.#yi-core4Describe the layout in a form suitable for the user.$yi-core<Cycles to the next variant, if there is one (the default is )%yi-core@Cycles to the previous variant, if there is one (the default is &yi-coreRelative sizes, for .'yi-core$Divider position, in the range (0,1)(yi-coreDivider reference)yi-coreOrientations for . and /,yi-coreUI-agnostic layout schema. The basic constructs are (horizontal/vertical) stacks with fixed ratios between window sizes; and (horizontal/vertical) pairs with a slider in between (if available).0yi-core Orientation1yi-coreZThe layout stack, with the given weights TODO: fix strictness for stack (it's still lazy)2yi-coreInitial position of the divider3yi-core8Index of the divider (for updating the divider position)4yi-coreUpper of of the pair5yi-coreLower of the pair6yi-coreAccessor for the ' with given reference7yi-core[Find the divider nearest to a given window, or just the first one in case the argument is 8yi-coreXTrue if the internal layout managers have the same type (but are not necessarily equal).9yi-core,Windows placed side-by-side, equally spaced.:yi-core4Windows placed on top of one another, equally spaced;yi-coreNTall windows, arranged in a balanced binary tree with sliders in between them.<yi-coreTransposed version of ;=yi-coren4 windows on the left; stack of windows on the right.>yi-coreTransposed version of =.Cyi-coreSpecial case of B with all &s equal.Eyi-core*The def layout consists of a single windowGyi-coreThe default layout is  tallLayout2 !"#$%&'()*+,/.-0123456789:;<=>?@ABCD2,/.-012345)*+'(&67!"#$% 8:9;<=>?A@BCDSafe*`yi-core'Combination of the Control.Monad.State modify and dyi-coreNRerun the monad until the boolean result is false, collecting list of results.`abcdefe`cdfbaSafe<4hyi-corehGiven a path relative to application data directory, this function finds a path to a given data file.iyi-corezGiven a path relative to application configuration directory, this function finds a path to a given configuration file.jyi-coreGiven an action that retrieves config path, and a path relative to it, this function joins the two together to create a config file path.kyi-core#Get Yi master configuration script.myi-core6Get path to Yi history that stores state between runs.nyi-coreTGet path to environment file that defines namespace used by Yi command evaluator.ghijklmnnklmgijhNoneV6v{yi-coreLRun a command using the system shell, returning stdout, stderr and exit codeopsqrtuvwxyz{|}~z|{}~opsqrtuvwxyGPL-2yi-devel@googlegroups.com experimentalportableSafeM yi-core!Helper that shows then packs the Text$, for all those cases where we use .yi-coreFThis is kind of like the default Show instance for lists except over T. It does not leave the elements in extra quotes and should not be attempted to be n and  back.yi-corepWorks by resupplying the found prefix back into the list, eventually either finding the prefix or not matching.yi-coreLike # but returns empty text on failure.yi-core%Remove any trailing strings matching irsC (input record separator) from input string. Like perl's chomp(1).yi-coreTrim spaces at beginning and endyi-coreHFills lines up to the given length, splitting the text up if necessary.yi-core overInit f runs f over the + of the input if possible, preserving the P element as-is. If given a string with length "d 1, it effectively does nothing. Also see .yi-core overInit f runs f over the + of the input if possible, preserving the P element as-is. If given a string with length "d 1, it effectively does nothing. Also see .yi-core Inverse of . In contrast to ., this does not add an empty line at the end.yi-coreSplit a Text in lines. Unlike 2, this does not remove any empty line at the end.yi-core7A helper function for creating functions suitable for modifySelectionB and  modifyRegionBQ. To be used when the desired function should map across the lines of a region.NoneVPyi-coreiTransform a scanner into a scanner that also adds opening, closing and "next" tokens to indicate layout.GPL-2yi-devel@googlegroups.com experimentalportableNone5;=Vmyi-coreDirect subtrees of a treeyi-corebPrune the nodes before the given point. The path is used to know which nodes we can force or not.yi-coreGiven an approximate path to a leaf at the end of the region, return: (path to leaf at the end of the region,path from focused node to the leaf, small node encompassing the region)yi-core^Return the first element that matches the predicate, or the last of the list if none matches.yi-coreReturn the element before first element that violates the predicate, or the first of the list if that one violates the predicate.yi-corekGiven a path to a node, return a path+node which node that encompasses the given node + a point before it.yi-coreSearch the tree in pre-order starting at a given node, until finding a leaf which is at or after the given point. An effort is also made to return a leaf as close as possible to p. TODO: rename to fromLeafToLeafAtyi-coretTakes a list of (node, index of already inspected child), and return all leaves in this node after the said child).yi-coresGiven a root, return all the nodes encountered along it, their paths, and the index of the child which comes next.yi-coreRReturn all leaves after or before child depending on the relation which is given.yi-core3Return all leaves (with paths) inside a given root.yi-core|Return all subtrees in a tree; each element of the return list contains paths to nodes. (Root is at the start of each path)yi-coreSearch the given list, and return the last tree before the given point; with path to the root. (Root is at the start of the path)yi-core+Return all subtrees in a tree, in preorder.yi-core"Return the 1st token of a subtree.yi-core#Return the last token of a subtree.yi-core5Given a tree, return (first offset, number of lines).GPL-2yi-devel@googlegroups.com experimentalportableNone345oNone>?CVpK  SafeQVyi-core)Record presenting a frontend's interface.The functions  and  are both run by the editor's main loop, in response to user actions and so on. Their relation is a little subtle, and is discussed here:'to see some code, look at the function  refreshEditor in Yi.Core#. This is the only place where  and  are used. the function ! is responsible for updating the Editor with the width and height of the windows. Some frontends, such as Pango, need to modify their internal state to do this, and will consequently change their display. This is expected. the function Q should cause the UI to update its display with the information given in the Editor.the functionalities of  and  overlap to some extent, in the sense that both may cause the frontend to update its display. The Yi core provides the following guarantees which the frontend may take advantage of:%in the main editor loop (i.e. in the  refreshEditor function), 0 will be run (possibly multiple times) and then W will be run. This guarantee will hold even in the case of threading (the function  refreshEditor& will always be run atomically, using MVars).between the last run of  and the run of $, some changes may be made to the Editor. However, the text, text attributes, and (displayed) window region of all windows will remain the same. However, the cursor location may change.SThis guarantee allows frontends which calculate rendering of the text during the 8 stage to avoid recalculating the render again during ). Pango is an example of such a frontend.OThe Yi core provides no guarantee about the OS thread from which the functions  and P are called from. In particular, subprocesses (e.g. compilation, ghci) will run  and  from new OS threads (see startSubprocessWatchers in Yi.Corei). The frontend must be preparaed for this: for instance, Gtk-based frontends should wrap GUI updates in  postGUIAsync.yi-core Main loopyi-core3Clean up, and also terminate if given an exit code.yi-core!Suspend (or minimize) the programyi-core#Refresh the UI with the given stateyi-coreGUser force-refresh (in case the screen has been messed up from outside)yi-coreSet window width and heightyi-coreReload cabal project views  GPL-2yi-devel@googlegroups.com experimentalportableNone1 yi-coreA window onto a buffer.yi-coreregular or mini window?yi-corethe buffer this window opens toyi-coreSlist of last accessed buffers (former bufKeys). Last accessed one is first elementyi-core;height of the window (in number of screen lines displayed)yi-core(width of the window (in number of chars)yi-coreGview area. note that the top point is also available as a buffer mark.yi-coreidentifier for the window (for UI sync) This is required for accurate scrolling. Scrolling depends on the actual number of buffer lines displayed. Line wrapping changes that number relative to the height so we can't use height for that purpose.yi-coreOThe actual number of buffer lines displayed. Taking into account line wrappingyi-core#Get the identification of a window.yi-core%Return a "fake" window onto a buffer.None1QVyi-core*A tab, containing a collection of windows.yi-coreFor UI sync; fixes #304yi-coreVisible windowsyi-core;Current layout. Invariant: must be the layout generated by , up to changing the 2s.yi-coreGlayout manager (for regenerating the layout when we add/remove windows)yi-core@Returns a list of all mini windows associated with the given tabyi-coreAccessor for the windows. If the windows (but not the focus) have changed when setting, then a relayout will be triggered to preserve the internal invariant.yi-coreiAccessor for the layout manager. When setting, will trigger a relayout if the layout manager has changed.yi-coreGets / sets the position of the divider with the given reference. The caller must ensure that the DividerRef is valid, otherwise an error will (might!) occur.yi-core A specialised version of "fmap".yi-coreForces all windows in the tabyi-core!Folds over the windows in the tabyi-core;Run the layout on the given tab, for the given aspect ratioyi-core Make a tab from multiple windowsyi-coreMake a tab from one windowyi-coreEquality on tab identity (the )GPL-2yi-devel@googlegroups.com experimentalportableNone 1345<>?CKV]4Iyi-core3Configuration record. All Yi hooks can be set here.yi-core UI to use.yi-coreUI-specific configuration.yi-core*Actions to run when the editor is started.yi-core<Actions to run after startup (after startActions) or reload.yi-coreDefault keymap to use.yi-core"List modes by order of preference.yi-core7Produce a .yi.dbg file with a lot of debug information.yi-coreSet to  for an emacs-like behaviour.yi-coreSet to S for an emacs-like behaviour, where all deleted text is accumulated in a killring.yi-coreList of layout managers for cycleLayoutManagersNextyi-core%Custom configuration, containing the s. Configure with configVariableA.yi-coreWhen should we use a "fat" cursor (i.e. 2 pixels wide, rather than 1)? Fat cursors have only been implemented for the Pango frontend.yi-core&Font name, for the UI that support it.yi-core&Font size, for the UI that support it.yi-coreStyle of scrollyi-core5Amount to move the buffer when using the scroll wheelyi-core/Should the scrollbar be shown on the left side?yi-core6Hide scrollbar automatically if text fits on one page.yi-core8Hide the tabbar automatically if only one tab is presentyi-core<Wrap lines at the edge of the window if too long to display.yi-core9The char with which to fill empty window space. Usually '~'/ for vi-like editors, ' ' for everything else.yi-core UI coloursyi-core'Should we show line numbers by default?"yi-coreThe Editor state$yi-coreFStack of all the buffers. Invariant: first buffer is the current one.&yi-core&Supply for buffer, window and tab ids.'yi-core6current tab contains the visible windows pointed list.(yi-coredynamic components,yi-coreMcurrently highlighted regex (also most recent regex for use in vim bindings).yi-core2Processed events that didn't yield any action yet./yi-core@Actions to be run when the buffer is closed; should be scrapped.2yi-core>Used to specify the behaviour of the automatic indent command.3yi-coreIncrease the indentation to the next higher indentation hint. If we are currently at the highest level of indentation then cycle back to the lowest.4yi-coreDecrease the indentation to the next smaller indentation hint. If we are currently at the smallest level then cycle back to the largest5yi-coreVIncrease the indentation to the next higher hint if no such hint exists do nothing.6yi-coredDecrease the indentation to the next smaller indentation hint, if no such hint exists do nothing.7yi-coreA Mode customizes the Yi interface for editing a particular data format. It specifies when the mode should be used and controls file-specific syntax highlighting and command input, among other things.9yi-core$so this can be serialized, debugged.:yi-core+What type of files does this mode apply to?;yi-coreSyntax highlighter<yi-corePrettify current "paragraph"=yi-core Buffer-local keymap modification>yi-coreemacs-style auto-indent line?yi-coreBFollow a "link" in the file. (eg. go to location of error message)Byi-corebStrokes that should be applied when displaying a syntax element should this be an Action instead?Cyi-core6An action that is to be executed when this mode is setDyi-core'buffer-local modeline formatting methodEyi-core.go to the point where the variable is declaredRyi-coreimmutable unique keySyi-coreundo/redo listTyi-coredynamic componentsUyi-core;prefered column to arrive at when we do a lineDown / lineUpVyi-core;prefered column to arrive at visually (ie, respecting wrap)Wyi-core6stick to the end of line (used by vim bindings mostly)Xyi-core/updates that haven't been synched in the UI yet]yi-core*time of the last synchronization with disk^yi-coreread-only flag_yi-core2the keymap is ready for insertion into this buffer`yi-core&does buffer contain directory contentsdyi-coreIHow many points (frontend-specific) to change the font by in this buffereyi-core`Updates that we've seen in this buffer, basically "write-only". Work-around for broken WriterT.qyi-coreCurrently duplicates some of Vim's indent settings. Allowing a buffer to specify settings that are more dynamic, perhaps via closures, could be useful.syi-core)Insert spaces instead of tabs as possibletyi-core Size of a Tabuyi-coreIndent by so many columnsvyi-core/The BufferM monad writes the updates performed.{yi-coreContent of the top-level loop.|yi-coreFor insertion-only modes}yi-core^The type of user-bindable functions TODO: doc how these are actually user-bindable are they?yi-core input streamyi-core output streamyi-core%The only mutable state in the program      !"#/.-,+*)'&%$(012654378EDCBA@?>=<;:9FGHIKJLNMOPedcba`_^]\[ZYXWVUTQRSfgjihklmponqrutsvwxyz|{}~}~yz|{vwxqrutslmponkfgjihOPedcba`_^]\[ZYXWVUTQRSLNMHIKJFG78EDCBA@?>=<;:92654310"#/.-,+*)'&%$( !     GPL-2yi-devel@googlegroups.com experimentalportableNone GPL-2yi-devel@googlegroups.com experimentalportableNoneB     '     !NoneKQVSyi-core4Fields that can be modified with all lens machinery.yi-core%The configuration monad. Run it with  configMain.yi-coreAccessor for any !, to be used by modules defining cs. Such modules should provide a custom-named field. For instance, take the following hypothetical :~@newtype UserName = UserName { unUserName :: String } deriving(Typeable, Binary, Default) instance YiConfigVariable UserName8$(nameDeriveAccessors ''UserName (n -> Just (n ++ "A"))) userName ::   userName = unUserNameA  @7Here, the hypothetical library would provide the field userName to be used in preference to customVariable.GPL-2yi-devel@googlegroups.com experimentalportableNone01345<CKNQV]yIEyi-core6Gets a short identifier of a buffer. If we're given a M+ then just wraps the buffer name like so: *name*. If we're given a N), it drops the number of path components.>let memBuf = newB (BufferRef 0) (MemBuffer "foo/bar/hello") ""shortIdentString 2 memBuf"*foo/bar/hello*"@let fileBuf = newB (BufferRef 0) (FileBuffer "foo/bar/hello") ""shortIdentString 2 fileBuf"hello"yi-core5Gets the buffer's identifier string, emphasising the M:>let memBuf = newB (BufferRef 0) (MemBuffer "foo/bar/hello") ""identString memBuf"*foo/bar/hello*"@let fileBuf = newB (BufferRef 0) (FileBuffer "foo/bar/hello") ""identString fileBuf"foo/bar/hello"yi-core6update the syntax information (clear the dirty "flag")yi-coreuIncreases the font size in the buffer by specified number. What this number actually means depends on the front-end.yi-coreuDecreases the font size in the buffer by specified number. What this number actually means depends on the front-end.yi-core8Given a buffer, and some information update the modelineON.B. the contents of modelines should be specified by user, and not hardcoded. yi-core;Given a point, and the file size, gives us a percent string yi-coreAdds an "overlay" to the buffer yi-coreRemove an existing "overlay"yi-core Execute a BufferMw value on a given buffer and window. The new state of the buffer is returned alongside the result of the computation.yi-core Execute a BufferM[ value on a given buffer, using a dummy window. The new state of the buffer is discarded.yi-core9Mark the current point in the undo list as a saved state.yi-coreUndo all updates that happened since last save, perform a given action and redo all updates again. Given action must not modify undo history.yi-coreWAnalogous to const, but returns a function that takes two parameters, rather than one.yi-core/Mode applies function that always returns True. yi-core0Mode applies function that always returns False."yi-coreCreate buffer named nm with contents s#yi-core Point of eof$yi-coreExtract the current point)yi-core'Move point in buffer to the given index,yi-core6Revert all the pending updates; don't touch the point.-yi-core6Write an element into the buffer at the current point..yi-core0Write the list into the buffer at current point./yi-core Insert newline at current point.0yi-core Insert given 3 at specified point, extending size of the buffer.1yi-core Insert the + at current point, extending size of buffer2yi-core:Insert the char at current point, extending size of bufferImplementation note: This just 2s a . This seems sub-optimal because we should be able to do much better without spewing chunks of size 1 everywhere. This approach is necessary however so an m{ can be recorded. A possible improvement for space would be to have yi-rope  package optimise for appends with length 1.3yi-core deleteNAt n p deletes n# characters forwards from position p4yi-coreReturn the current line number5yi-coreTop line of the screen6yi-coreMiddle line of the screen7yi-coreBottom line of the screenyi-coreAmount of lines in the screen8yi-coreReturn line numbers of marks9yi-coreGo to line number n. ny is indexed from 1. Returns the actual line we went to (which may be not be the requested line, if it was out of range);yi-core Set the mode=yi-coreModify the modeDyi-coreJReturn indices of strings in buffer matched by regex in the given region.Eyi-corePReturn indices of next string in buffer matched by regex in the given directionIyi-coreHighlight the selectionJyi-core$Whether the selection is highlightedNyi-corehMove point by the given number of characters. A negative offset moves backwards a positive one forward.Oyi-core Move point -1Pyi-coreMove cursor -nQyi-coreMove cursor +1Ryi-coreMove cursor +nSyi-coreMove point down by n lines. n can be negative. Returns the actual difference in lines which we moved which may be negative if the requested line difference is negative.Uyi-coreMoves to a visual column within the current line as shown on the editor (ie, moving within the current width of a single visual line)[yi-coreMove point up one line\yi-coreMove point down one line]yi-core"Return the contents of the buffer.^yi-core:Returns the contents of the buffer between the two points.If the startPoint >= endPoint, empty string is returned. If the points are out of bounds, as much of the content as possible is taken: you're not guaranteed to get endPoint - startPoint characters._yi-core'Read the character at the current point`yi-corepRead the character at the given index This is an unsafe operation: character NUL is returned when out of boundsfyi-coreDelete n* characters forward from the current pointgyi-core Gives the q for the current buffer.hyi-coreCurrent column. Note that this is different from offset or number of chars from sol. (This takes into account tabs, unicode chars, etc.)yi-coreCurrent column, visually.yi-core?Decides which column we should be on after the given character.lyi-core.Returns start of line point for a given point pmyi-core$Returns end of line for given point.nyi-coreGo to line indexed from current point Returns the actual moved difference which of course may be negative if the requested difference was negative.oyi-corehAccess to a value into the extensible state, keyed by its type. This allows you to retrieve inside a v monad, ie: value <- getBufferDynpyi-coredAccess to a value into the extensible state, keyed by its type. This allows you to save inside a v monad, ie: putBufferDyn updatedvalueqyi-core perform a  BufferM a4, and return to the current point. (by using a mark)syi-core Perform an  BufferM a", and return to the current point.tyi-core Perform an  BufferM aU, and return to the current line and column number. The difference between this and s is that here we attempt to return to the specific line and column number, rather than a specific number of characters from the beginning of the buffer.HIn case the column is further away than EOL, the point is left at EOL: W is used internally.wyi-core_What would be the point after doing the given action? The argument must not modify the buffer.zyi-coreJust stores the mode name.yi-core2Number of characters to drop from FileBuffer namesyi-coreBuffer to work with^yi-corePoint to start atyi-corePoint to stop atfghityvwux}23456789:;<=>?@ABCDEFGLMNfghijklmnqrstuvwx      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxylmnvwxkfghij5674hijk#$Xlm8)VWS[\"fghityvwux}9nOQNPR102f%-./3_]LGHMrFJI;<:=DE` *ZYTU   qst,xB789:;<=>?@ABCDEFG23456qrstu !@?>AC(&'KupoLMNabcdevwy+^g "GPL-2yi-devel@googlegroups.com experimentalportableNone yi-core&Delete an arbitrary part of the bufferyi-core#Replace a region with a given rope.yi-core9Map the given function over the characters in the region.yi-coreSwap the content of two Regionsyi-corePModifies the given region according to the given string transformation functionyi-core1Extend the right bound of a region to include it.yi-coreSee a region as a block/rectangular region, since regions are represented by two point, this returns a list of small regions form this block region.yi-coreIJoins lines in the region with a single space, skipping any empty lines.yi-coreIConcatenates lines in the region preserving the trailing newline if any.yi-coreGets the lines of a region (as a region), preserving newlines. Thus the resulting list of regions is a partition of the original region.]The direction of the region is preserved and all smaller regions will retain that direction.`Note that regions should never be empty, so it would be odd for this to return an empty list...yi-core|Given some text and the previous region, finds the next region (used for implementing linesOfRegionB, not generally useful)yi-core The string modification functionyi-coreThe region to modify  #GPL-2yi-devel@googlegroups.com experimentalportableNone1#yi-core Boundary sideyi-core!Designate a given "unit" of text.yi-corea single characteryi-core!a line of text (between newlines)yi-coreYa "vertical" line of text (area of text between two characters at the same column number)yi-corethe whole documentyi-coreLTurns a unit into its "negative" by inverting the boundaries. For example, outsideUnit unitViWordJ will be the unit of spaces between words. For units without boundaries (, ', ...), this is the identity function.yi-core8Common boundary checking function: run the condition on len@ characters in specified direction shifted by specified offset.yi-core,a word as in use in Emacs (fundamental mode)yi-corekdelimited on the left and right by given characters, boolean argument tells if whether those are included.yi-core$Tells if a char can end a sentence (, !, ?).yi-corejVerifies that the string matches all the predicates, pairwise. If the string is "too small", then return 2. Note the length of predicates has to be finite.yi-core^Helper that takes first two characters of YiString. Faster than take 2 and string conversion.yi-coreTSeparator characters (space, tab, unicode separators). Most of the units above attempt to identify "words" with various punctuation and symbols included or excluded. This set of units is a simple inverse: it is true for "whitespace" or "separators" and false for anything that is not (letters, numbers, symbols, punctuation, whatever).yi-core4unitSep is true for any kind of whitespace/separatoryi-coreNunitSepThisLine is true for any kind of whitespace/separator on this line onlyyi-coreIs the point at a Unit boundary in the specified  Direction?yi-coreFParagraph to implement emacs-like forward-paragraph/backward-paragraphyi-coreTParagraph that begins and ends in the paragraph, not the empty lines surrounding it.yi-coreWUnit that have its left and right boundaries at the left boundary of the argument unit.yi-coregenAtBoundaryB u d s2 returns whether the point is at a given boundary (d,s) . Boundary (d,s) , taking Word as example, means: Word ^^ ^^ 12 34 1: (Backward,OutsideBound) 2: (Backward,InsideBound) 3: (Forward,InsideBound) 4: (Forward,OutsideBound)rules: genAtBoundaryB u Backward InsideBound = atBoundaryB u Backward genAtBoundaryB u Forward OutsideBound = atBoundaryB u Forwardyi-corevRepeat an action until the condition is fulfilled or the cursor stops moving. The Action may be performed zero times.yi-coreuRepeat an action until the condition is fulfilled or the cursor stops moving. The Action is performed at least once.yi-coreADo an action if the current buffer character passes the predicateyi-corevGeneric move operation Warning: moving To the (OutsideBound, Backward) bound of Document is impossible (offset -1!) genMoveB u b dC: move in direction d until encountering boundary b or unit u. See  for boundary explanation.yi-coreYGeneric maybe move operation. As genMoveB, but don't move if we are at boundary already.yi-coreMove to the next unit boundaryyi-coreAs (, unless the point is at a unit boundaryyi-coreTransforms the region given by  in the # with user-supplied function.yi-coreGDelete between point and next unit boundary, return the deleted region.yi-core8Region of the whole textunit where the current point is.yi-coreBNon empty region of the whole textunit where the current point is.yi-coreeRegion between the point and the next boundary. The region is empty if the point is at the boundary.yi-corexNon empty region between the point and the next boundary, In fact the region can be empty if we are at the end of file.yi-core6Non empty region at given point and the next boundary,yi-coreOffset from current positionyi-core Look-aheadyi-core predicateyi-coreDirection to look in66$Noneyi-coreExtend the given region to boundaries of the text unit. For instance one can extend the selection to complete lines, or paragraphs.>>%GPL-2yi-devel@googlegroups.com experimentalportableNone]^9Yyi-coreMove point between the middle, top and bottom of the screen If the point stays at the middle, it'll be gone to the top else if the point stays at the top, it'll be gone to the bottom else it'll be gone to the middleyi-coreMove point to start of lineyi-coreMove point to end of lineyi-coreMove cursor to originyi-coreMove cursor to end of bufferyi-core*Move left if on eol, but not on blank lineyi-coreMove x- chars back, or to the sol, whichever is lessyi-coreMove x0 chars forward, or to the eol, whichever is lessyi-core(Move to first char of next word forwardsyi-core)Move to first char of next word backwardsyi-coreMove to the next occurence of cyi-core3Move to the character before the next occurence of cyi-core"Move to the previous occurence of cyi-core6Move to the character after the previous occurence of cyi-core.Move to first non-space character in this lineyi-core1Move to the last non-space character in this lineyi-coreiGo to the first non space character in the line; if already there, then go to the beginning of the line.yi-core?True if current line consists of just a newline (no whitespace)yi-coreINote: Returns False if line doesn't have any characters besides a newlineyi-coreMove down next n paragraphsyi-core Move up prev n paragraphsyi-core Select next n paragraphsyi-core7Return true if the current point is the start of a lineyi-core5Return true if the current point is the end of a lineyi-coreTrue if point at start of fileyi-coreTrue if point at end of fileyi-coreTrue if point at the last lineyi-core&Get the current line and column numberyi-coreRead the line the point is onyi-core$Read from point to beginning of lineyi-core;Get the previous point, unless at the beginning of the fileyi-coreReads in word at point.yi-coreReads in word before point.yi-coreDelete one character backwardyi-coreTDelete forward whitespace or non-whitespace depending on the character under point. yi-coreVDelete backward whitespace or non-whitespace depending on the character before point. yi-core4Delete backward to the sof or the new line character yi-coreemacs' delete-horizontal-space with the optional argument. yi-core$capitalise the word under the cursor yi-corelowerise word under the cursoryi-core(capitalise the first letter of this wordyi-core(Delete to the end of line, excluding it.yi-core0Transpose two characters, (the Emacs C-t action)yi-core0Delete trailing whitespace from all lines. Uses t to get back to where it was.yi-coreMarks%Set the current buffer selection markyi-core%Get the current buffer selection markyi-coreExchange point & mark.yi-core=File info, size in chars, line no, col num, char num, percentyi-coreScroll up 1 screenyi-coreScroll down 1 screenyi-core%Scroll by n screens (negative for up)yi-core*Same as scrollB, but also moves the cursoryi-core,Same as scrollByB, but also moves the cursoryi-coreMove to middle line in screen yi-core$Move cursor to the top of the screen!yi-core'Move cursor to the bottom of the screen"yi-coreScroll by n lines.%yi-core,Move the point to inside the viewable regionyi-corereturn index of Sol on line n above current lineyi-core&return relative position of the point p/ relative to the region defined by the points rs and re&yi-core,Move the visible region to include the point'yi-coreMove to n lines down from top of screen(yi-coreMove to n' lines up from the bottom of the screen)yi-coreMove to middle line in screen*yi-core(Return the region between point and markyi-core8Return the empty region if the selection is not visible.+yi-coreJGet the current region boundaries. Extended to the current selection unit.,yi-core7Select the given region: set the selection mark at the  and the current point at the ..yi-core<Get a (lazy) stream of lines in the buffer, starting at the next line in the given direction. yi-coreGGet the next line of text in the given direction. This returns simply  if there no such line./yi-core The same as   but avoids the use of the  M type in the return by returning the empty string if there is no next line. yi-coreGet closest line to the current line (not including the current line) in the given direction which satisfies the given condition. Returns 4 if there is no line which satisfies the condition.0yi-coreReturns the closest line to the current line which is non-blank, in the given direction. Returns the empty string if there is no such line (for example if we are on the top line already).2yi-core9Prefix each line in the selection using the given string.3yi-coreUncomments the selection using the given line comment starting string. This only works for the comments which begin at the start of the line.4yi-core Just like  X but automatically inserts a whitespace suffix to the inserted comment string. In fact: yi-coreSToggle line comments in the selection by adding or removing a prefix to each line.5yi-core3Replace the contents of the buffer with some string yi-core9Fill the text in the region so it fits nicely 80 columns.7yi-coreSort the lines of the region.yi-core7Forces an extra newline into the region (if one exists)9yi-coreBHelper function: revert the buffer contents to its on-disk versionDyi-core<Increase (or decrease if negative) next number on line by n.yi-core Increment number in string by n.Eyi-core#Is character under cursor a number.Fyi-coreGUsed by isNumber to test if current character under cursor is a number.Gyi-core Characters ['a'..'f'V] are part of a hex number only if preceded by 0x. Test if the current occurence of ['a'..'f'] is part of a hex number.Hyi-coreMove point down by nn lines If line extends past width of window, count moving a single line as moving width points to the right.Iyi-core&Implements the same logic that emacs'  `mark-word`L does. Checks the mark point and moves it forth (or backward) for one word.2yi-core%The string that starts a line comment3yi-core'The string which begins a line commentyi-core3A potentially shorter string that begins a commentr      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIr  - >'6CA/0*+D@E;H2. )1B?59<"! #$,:78%&=FG43( I&GPL-2yi-devel@googlegroups.com experimentalportableNone]Kyi-coreReturn either a t or the number of spaces specified by tabSize in the IndentSettings. Note that if you actually want to insert a tab character (for example when editing makefiles) then you should use: insertB '\t'.Lyi-coreA specialisation of F. This is the most basic and the user is encouraged to specialise  on their own.yi-coreThis takes two arguments the first is a function to obtain indentation hints from lines above the current one. The second is a function to obtain a set of indentation hints from the previous line. Both of these are in the v monad although the second seems like it is unnecessary. However we must take into account the length of tabs which come from the the tab settings and hence we must be in the v monad.To get the straightforward behaviour of the indents of all previous lines until one of them has zero indent call this with: ?autoIndentHelperB fetchPreviousIndentsB (fmap (: []) indentOfB) However commonly we wish to have something more interesting for the second argument, in particular we commonly wish to have the last opening bracket of the previous line as well as its indent.Myi-coreCycles through the indentation hints. It does this without requiring to set/get any state. We just look at the current indentation of the current line and moving to the largest indent that isyi-core7A function generally useful as the first argument to . This searches the lines above the current line for the indentations of each line until we get to a line which has no indentation *and* is not empty. Indicating that we have reached the outer scope.yi-coreNReturns the position of the last opening bracket on the line which is not closed on the same line. Note that if we have unmatched parentheses such as "( ]" then we may not get the correct answer, but in that case then arguably we don't really care if we get the correct answer (at least if we get it wrong the user may notice their error). We return a list here as it's a convenient way of returning no hint in the case of there being no non-closed bracket and normally such a hint will be part of a list of hints anyway. NOTE: this could be easily modified to return the indentations of *all* the non-closed opening brackets. But I think this is not what you generally want. TODO: we also do not care whether or not the bracket is within a string or escaped. If someone feels up to caring about that by all means please fix this.Nyi-coregReturns the indentation of a given string. Note that this depends on the current indentation settings.yi-coregReturns the length of a given string taking into account the white space and the indentation settings.Oyi-coreIndents the current line to the given indentation level. In addition moves the point according to where it was on the line originally. If we were somewhere within the indentation (ie at the start of the line or on an empty line) then we want to just go to the end of the (new) indentation. However if we are currently pointing somewhere within the text of the line then we wish to remain pointing to the same character.Pyi-coreModifies current line indent measured in visible spaces. Respects indent settings. Calling this with value (+ 4) will turn "t" into "tt" if shiftwidth is 4 and into "t " if shiftwidth is 8 If current line is empty nothing happens.Qyi-core#Indent as much as the previous lineRyi-coreIndent as much as the next lineTyi-coreFInsert a newline at point and indent the new line as the previous one.yi-corenSet the padding of the string to newCount, filling in tabs if expandTabs is set in the buffers IndentSettingsyi-core0Counts the size of the indent in the given text.*Assumes nothing but tabs and spaces: uses .yi-corexshifts right (or left if num is negative) num times, filling in tabs if expandTabs is set in the buffers IndentSettingsUyi-coreIIncreases the indentation on the region by the given amount of shiftWidthVyi-coreKReturn the number of spaces at the beginning of the line, up to the point.yi-core)Action to fetch hints from previous linesyi-core,Action to calculate hints from previous lineyi-core Sets the indent behaviour, see  H for a description gKLMNOPQRSTUV LMRQSNVgOPTUK GPL-2yi-devel@googlegroups.com experimentalportableNone  #"!&%$('+*).-,10/fghijklmnopqrstyvwuxz{|}~23456789:;<=>?@ABCDEFGLMNfghijklmnqrstuvwx      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIKLMNOPQRSTUV jklmnopqrs|z{'GPL-2yi-devel@googlegroups.com experimentalportableNone<]Yyi-coreTurn a sequence of (from,style,to) strokes into a sequence of picture points (from,style), taking special care to ensure that the points are strictly increasing and introducing padding segments where neccessary. Precondition: Strokes are ordered and not overlapping.Zyi-core<Paint the given stroke-picture on top of an existing picture^yi-core0Arrange a list of items in columns over maximum maxNumberOfLines lines_yi-core(Arrange a list of items in columns over  numberOfLines lines.)TODO: proper Text/YiString implementation WXYZ[\]^_ WXYZ[\]^_(GPL-2yi-devel@googlegroups.com experimentalportableNone16``yi-core)Get the buffer-local line number setting.ayi-coreSet the buffer-local line number setting. Nothing: use global setting Just True: display line numbers only in this buffer Just False: hide line numbers only in this buffer`a`a)GPL-2yi-devel@googlegroups.com experimentalportableNone]8fyi-coreThe initial statetyi-coreCreate and fill a new buffer, using contents of string. | Does not focus the window, or make it the current window. | Call newWindowE or switchToBufferE to take care of that.uyi-core;Delete a buffer (and release resources associated with it).vyi-coreReturn the buffers we have, in no particular orderwyi-coreUReturn a prefix that can be removed from all buffer paths while keeping them unique.zyi-coreFind buffer with this key{yi-coreFind buffers with this name}yi-core/Find buffer with given name. Fail if not found.~yi-core[Perform action with any given buffer, using the last window that was used for that buffer.yi-core$Perform action with any given bufferyi-core+Perform action with current window's bufferyi-coreReturn the current bufferyi-corePrints a message with .yi-core!Prints a all given messages with .yi-core Set the "background" status lineyi-coreClear the status lineyi-corePut string into yank registeryi-core(Return the contents of the yank registeryi-core(Dynamically-extensible state components.These hooks are used by keymaps to store values that result from Actions (i.e. that restult from IO), as opposed to the pure values they generate themselves, and can be stored internally.The ( field is a type-indexed map.*Retrieve a value from the extensible stateyi-core;Insert a value into the extensible state, keyed by its typeyi-core7Like fnewE, create a new buffer filled with the String s, Switch the current window to this buffer. Doesn't associate any file with the buffer (unlike fnewE) and so is good for popup internal buffers (like scratch)yi-coreLike  but defaults to empty contents.yi-core/Create a new zero size window on a given bufferyi-core*Create a new window onto the given buffer.yi-core1Attach the specified buffer to the current windowyi-coreeSwitch to the buffer specified as parameter. If the buffer name is empty, switch to the next buffer.yi-coreLClose a buffer. Note: close the current buffer if the empty string is givenyi-core:Close current buffer and window, unless it's the last one.yi-coreRotate focus to the next windowyi-core#Rotate focus to the previous windowyi-coreLSwaps the focused window with the first window. Useful for layouts such as  HPairOneStack-, for which the first window is the largest.yi-coreZMoves the focused window to the first window, and moves all other windows down the stack.yi-core%Swap focused window with the next oneyi-core)Swap focused window with the previous oneyi-coreVA "fake" accessor that fixes the current buffer after a change of the current window.QEnforces invariant that top of buffer stack is the buffer of the current window.yi-coreLReturn the windows that are currently open on the buffer whose key is givenyi-core5bring the editor focus the window with the given key./Fails if no window with the given key is found.yi-coreeSplit the current window, opening a second window onto current buffer. TODO: unfold newWindowE here?yi-coreFPrints the description of the current layout manager in the status baryi-coreVCycle to the next layout manager, or the first one if the current one is nonstandard.yi-coreZCycle to the previous layout manager, or the first one if the current one is nonstandard.yi-coreHelper function for layoutManagersNext and layoutManagersPreviousyi-core8Next variant of the current layout manager, as given by $yi-core=Previous variant of the current layout manager, as given by %yi-core2Sets the given divider position on the current tabyi-coreDCreates a new tab containing a window that views the current buffer.yi-core4Moves to the next tab in the round robin set of tabsyi-core8Moves to the previous tab in the round robin set of tabsyi-coreWMoves the focused tab to the given index, or to the end if the index is not specified.yi-coreDeletes the current tab. If there is only one tab open then error out. When the last tab is focused, move focus to the left, otherwise move focus to the right.yi-corenClose the current window. If there is only one tab open and the tab contains only one window then do nothing.yi-core5Make the current window the only window on the screenyi-coreDSwitch focus to some other window. If none is available, create one.yi-coreExecute the argument in the context of an other window. Create one if necessary. The current window is re-focused after the argument has completed.yi-core.Shows the current key bindings in a new windowyi-core/Creates an in-memory buffer with a unique name.tyi-coreThe buffer indentifieryi-core/The contents with which to populate the bufferyi-core buffer nameyi-corebuffer contentse"#($%&')*+,-./fhijklmnopqrstuvwxyz{|}~e"#($%&')*+,-./svhwiu|fyz{x}jklmnotrpq~*GPL-2yi-devel@googlegroups.com experimentalportableNoneOyi-coreZA TabDescr describes the properties of a UI tab independent of the particular GUI in use.+None%<,GPL-2yi-devel@googlegroups.com experimentalportableNone16<K yi-core@local name of the tag file TODO: reload if this file is changedyi-core>path to the tag file directory tags are relative to this pathyi-coremap from tags to filesyi-coretrie to speed up tag hintingyi-coreTFind the location of a tag using the tag table. Returns a full path and line numberyi-coreiSuper simple parsing CTag format 1 parsing algorithm TODO: support search patterns in addition to linenoyi-core"Read in a tag file from the systemyi-core>Gives all the possible expanded tags that could match a given prefixyi-core0Extends the string to the longest certain lengthyi-coreSet a new TagTableyi-coreReset the TagTableyi-core&Get the currently registered tag table-GPL-2yi-devel@googlegroups.com experimentalportableNone=yi-corePut regex into regex registeryi-coreClear the regex registeryi-core!Return contents of regex register.GPL-2yi-devel@googlegroups.com experimentalportableNoneU8yi-coreGet the selected region as a rectangle. Returns the region extended to lines, plus the start and end columns of the rectangle.yi-core"Split text at the boundaries given/GPL-2yi-devel@googlegroups.com experimentalportableNone01;<=>?ACKQVyi-corewrite a/ returns a keymap that just outputs the action a.yi-core withModeY f runs fd on the current buffer's mode. As this runs in the YiM monad, we're able to do more than with just  withModeBB such as prompt the user for something before running the action.yi-corePredicate to select exceptionsyi-coreComputation to runyi-coreHandler6yz{|}~  6yz{|  }~0GPL-2yi-devel@googlegroups.com experimentalportableNone< yi-core5Parse any character that can be inserted in the text.%yi-core optMod f ev produces a  that consumes ev or f ev&yi-core#Convert a special key into an event'yi-core p >>! act = p >> 'write' act(yi-core  p >>=! act = p >>= 'write' . act)yi-core  ev ?>> proc =  ev >> proc*yi-core  ev ?>>! act =  ev >>  act+yi-core  ev ?*>> proc =  ev >> proc,yi-core  ev ?*>>! act =  ev >>  actQ !"#$%&'()*+,Q &!'()*+,"#$%'1(1)0*0+0,01None-yi-coreThe class of "valid hooks". This class is exported abstractly, but the instances can be phrased quite simply: the functions (of arbitrarily many arguments, including zero) which run in either the  or } monads.)A typical example would be something likeInt -> String ->  String..yi-coreJLooks up the configured value for the hook, and runs it. The argument to .+ will typically be a record accessor. See - for the valid hook types.-..-2GPL-2yi-devel@googlegroups.com experimentalportableNone%2yi-core[Remove anything starting with uppercase letter. These denote either module names or types.3yi-coreHoogle's output includes a sort of type keyword, telling whether a hit is a package name, syntax, a module name, etc. But we care primarily about the function names, so we filter out anything containing the keywords.4yi-coretQuery Hoogle, with given search and options. This errors out on no results or if the hoogle command is not on path.5yi-coreFilter the output of 4 to leave just functions.6yi-coreReturn module-function pairs.7yi-core Call out to 6D, and overwrite the word at point with the first returned function.8yi-core Call out to 4Z, and print inside the Minibuffer the results of searching Hoogle with the word at point.234567823456783GPL-2yi-devel@googlegroups.com experimentalportableNone1;=QV+hEyi-core#Start an input session with HistoryGyi-core.Finish the current input session with history.Myi-core0Helper that sets the given history at ident and s the result.Myi-core identifieryi-coreHistory to setyi-coreMap of existing histories9:=<;>?@ABCDEFGHIJKLM>?9:=<;@ABCDEFGHIJKLMGPL-2yi-devel@googlegroups.com experimentalportableNone1K]Z[yi-coreEGlobal searching. Search for regex and move point to that position. Nothing* means reuse the last regular expression. Just s means use sP as the new regular expression. Direction of search can be specified as either Backward or Forwardi (forwards in the buffer). Arguments to modify the compiled regular expression can be supplied as well.]yi-coreSet up a search.^yi-coreDo a search, placing cursor at first char of pattern, if found. Keymaps may implement their own regex language. How do we provide for this? Also, what's happening with ^ not matching sol?_yi-core2Search and Replace all within the current region. Note the region is the final argument since we might perform the same search and replace over multiple regions however we are unlikely to perform several search and replaces over the same region since the first such may change the bounds of the region.`yi-core,Peform a search and replace on the selectionayi-core6Replace a string by another everywhere in the documentbyi-core'Search and replace in the given region.If the input boolean is True, then the replace is done globally, otherwise only the first match is replaced. Returns the number of replacements done.dyi-coreOSearch and replace in the region defined by the given unit. The rest is as in c.hyi-core4Create a SearchExp that matches exactly its argumentnyi-core&Succesfully finish a search. Also see p.oyi-coreCancel a search. Also see q.pyi-core Wrapper over x that passes through the action and accepts the search as successful (i.e. when the user wants to stay at the result).qyi-core Wrapper over  that passes through the action and marks the search as unsuccessful (i.e. when the user wants to jump back to where the search started).yi-coreDEditor action describing how to end finish incremental search. The act parameter allows us to specify an extra action to run before finishing up the search. For Vim, we don't want to do anything so we use [ which just does nothing. For emacs, we want to cancel highlighting and stay where we are.yi-core Specialised  to do nothing as the action.ryi-coreDFind the next match and select it. Point is end, mark is beginning.syi-core&Replace all the remaining occurrences.tyi-coreExit from query/replace.uyi-coreIWe replace the currently selected match and then move to the next match.yi-coreThis may actually be a bit more general it replaces the current selection with the given replacement string in the given window and buffer.\yi-coreNothingh means used previous pattern, if any. Complain otherwise. Use getRegexE to check for previous patternsyi-core"Flags to modify the compiled regexyi-coreBackward or Forward_yi-coreThe string to search foryi-coreThe string to replace it withyi-coreThe region to perform this over`yi-coretext to search foryi-coretext to replace it with&WXYZ[\]^_`abcdefghijklmnopqrstu&[WXYZ\]^h_`acbdefgklmjionqprsut4None16KVeFyi-coreBTrims per-command histories to contain at most N completions each.yi-core{Here is a persistent history saving part. We assume each command is a single line. To add new components, one has to:add new field in PersistentState structure,add write and read parts in loadPersistentState/savePersistentState,add a trimming code in savePersistentState) to prevent blowing up of save file. yi-coreQReads and decodes a persistent state in both strict, and exception robust way.yi-coreBLoads a persistent state, and sets Yi state variables accordingly.GPL-2yi-devel@googlegroups.com experimentalportableNoneK yi-core Like usual !- but user can specify case sensitivity. See " for exotic unicode gotchas.yi-core'Prefix matching function, for use with yi-core0Text from the match up to the end, for use with yi-core>A simple fuzzy match algorithm. Example: "abc" matches "a1b2c"yi-core>A simple fuzzy match algorithm. Example: "abc" matches "a1b2c"yi-coreUTODO: this is a terrible function, isn't this just case-insensitive infix?  Fkzetsuyi-coreComplete a string given a user input string, a matching function and a list of possibilites. Matching function should return the part of the string that matches the user string.yi-coreSame as  , but maps  showFunction# on possible matches when printing#yi-coreThis function attempts to provide a better tab completion result in cases where more than one file matches our prefix. Consider directory with following files: 5["Main.hs", "Main.hi", "Main.o", "Test.py", "Foo.hs"].After inserting Mai[ into the minibuffer and attempting to complete, the possible matches will be filtered in  to  ["Main.hs", "Main.hi", "Main.o"]M however because of multiple matches, the buffer will not be updated to say Main. but will instead stay at Mai.This is extremely tedious when trying to complete filenames in directories with many files so here we try to catch common prefixes of filtered files and if the result is longer than what we have, we use it instead.yi-coreIs case-sensitive?yi-coreInput to match onyi-corematcher functionyi-coreitems to match againstyi-core Show functionyi-coreInput to match onyi-corematcher functionyi-coreitems to match against 2 25GPL-2yi-devel@googlegroups.com experimentalportableNone1K$yi-coreWord completion[when doing keyword completion, we need to keep track of the word we're trying to complete.yi-coreSwitch out of completion mode.yi-coreqTry to complete the current word with occurences found elsewhere in the editor. Further calls try other options.yi-coreExtract functionyi-coreSource functionyi-coreMessage functionyi-corePredicate matcher  6GPL-2yi-devel@googlegroups.com experimentalportableNoneLQV]%yi-coreFMake an action suitable for an interactive run. UI will be refreshed.yi-coreqStart up the editor, setting any state with the user preferences and file names passed in, and turning on the UI&yi-core=Display the errors buffer in a new split window if it exists.'yi-core^Process events by advancing the current keymap automaton and executing the generated actions.yi-coreQuit.yi-coreEQuit with an exit code. (This is used to implement vim's :cq command)(yi-corelUpdate (visible) buffers if they have changed on disk. FIXME: since we do IO here we must catch exceptions!)yi-core;Hide selection, clear "syntax dirty" flag (as appropriate).yi-coreRedrawyi-coreSuspend the programyi-corepPipe a string through an external command, returning the stdout chomp any trailing newline (is this desirable?)Todo: varients with marks?*yi-coreSame as %, but do nothing instead of printing ()yi-core,Show an error on the status line and log it.yi-coreMClose the current window. If this is the last window open, quit the program.ACONSIDER: call quitEditor when there are no other window in the %Y function. (Not possible since the windowset type disallows it -- should it be relaxed?)yi-coreThis is a like  but with emacs behaviour of C-x 0: if we're trying to close the minibuffer or last buffer in the editor, then just print a message warning the user about it rather closing mini or quitting editor.+yi-coreKill a given subprocessyi-core8Start a subprocess with the given command and arguments.,yi-core Appends a  to the given buffer.BTODO: Figure out and document the Bool here. Probably to do with -.,yi-coreBuffer to append toyi-coreText to append7GPL-2yi-devel@googlegroups.com experimentalportableNone 1;=>?KSTV]S .yi-core-What to prompt the user when asked this type?yi-coreTag a type with a documentationyi-core+Prompts for a buffer name, turns it into a (O and passes it on to the handler function. Uses all known buffers for hinting.yi-core@Prompts the user for comment syntax to use for the current mode.yi-coreOpen a minibuffer window with the given prompt and keymap The third argument is an action to perform after the minibuffer is opened such as move to the first occurence of a searched for string. If you don't need this just supply  return ()yi-core#withMinibuffer prompt completer act: open a minibuffer with prompt. Once a string s is obtained, run act s.  completerK can be used to complete functions: it returns a list of possible matches.yi-coreMakes a completion function.yi-core.Hint function that does nothing, for use with yi-corewithMinibufferFree prompt act: Simple version of yi-core@withMinibufferGen proposal getHint prompt completer onTyping act: open a minibuffer with prompt, and initial content proposal. Once a string s is obtained, run act s.  completer can be used to complete inputs by returning an incrementally better match, and getHint can give an immediate feedback to the user on the current input. on Typingu is an extra action which will fire with every user key-press and receives minibuffer contents. Use something like const $ return () if you don't need this.yi-core8Open a minibuffer, given a finite number of suggestions./yi-core*TODO: decide whether we should be keeping  here or moving to YiString.yi-coreReturns all the buffer namesyi-corePromptyi-coreHandleryi-coreHint pre-processor. It takes the list of open buffers and a list of all buffers, and should spit out all the buffers to possibly hint, in the wanted order. Note the hinter uses name prefix for filtering regardless of what you do here.yi-coreList completion, such as .yi-coreMatcher such as yi-core.Function to fetch possibilites for completion.yi-core!Input to try and complete against8GPL-2yi-devel@googlegroups.com experimentalportableNone yi-coreThe only built in mode of yi0yi-core Creates a  from a 1( and a function that turns tokens into 2.yi-coreSpecialised version of 0* for the common case, wrapping up into a 1 with 3.yi-coreHDetermines if the file's extension is one of the extensions in the list.yi-core.When applied to an extensions list, creates a IJ function.yi-coreNWhen applied to an extensions list and regular expression pattern, creates a IJ function.yi-coretGenerate a parser for shebang patterns the generated parser will match only if the shebang is at the start of a lineExamples shebangParser "runhaskell"generates a parser that matches "#!/usr/bin/env runhaskell\n" (but also "djsjfaj\n\n\n\r\n#! /usr/bin/env runhaskell \ndkasfkda\n\r\nkasfaj")Note: You can get ("runhaskell" :: Parser String)) by using the OverloadedStrings extension shebangParser "python"9generates a parser that matches "#!/usr/bin/env python\n"Note:Q it doesn't match "#!/usr/bin/env python2\n" (that's why the newline is required)0It is also possible to use more complex parsers: 0shebangParser ("python" *> ("2" <|> "3" <|> ""))'generates a parser that matches any of:"#!/usr/bin/env python\n""#!/usr/bin/env python2\n""#!/usr/bin/env python3\n"yi-core+Adds a hook to all matching hooks in a listyi-core0Apply a list of mode hooks to a list of AnyModesyi-coresCheck whether a mode of the same name is already in modeTable and returns the original mode, if it isn't the case.yi-coreStarting stateyi-coreList of extensionsyi-corePath to compare againstyi-core)File contents. Currently unused but see .  9GPL-2yi-devel@googlegroups.com experimentalportableNoneNST]R yi-coreGiven a possible starting path (which if not given defaults to the current directory) and a fragment of a path we find all files within the given (or current) directory which can complete the given path fragment. We return a pair of both directory plus the filenames on their own that is without their directories. The reason for this is that if we return all of the filenames then we get a hint1 which is way too long to be particularly useful.yi-corebGiven a path, trim the file name bit if it exists. If no path given, return current directory.yi-core?Given a possible path and a prefix, return matching file names.yi-core\Place mark at current point. If there's an existing mark at point already, deactivate mark.yi-core'Select the contents of the whole bufferyi-coreA simple wrapper to adjust the current indentation using the mode specific indentation function but according to the given indent behaviour.yi-core0Generic emacs style prompt file action. Takes a prompt and a continuation act& and prompts the user with file hints.yi-coreAs r but additionally allows the caller to transform the list of hints arbitrarily, such as only showing directories.4yi-coreFor use as the hint when opening a file using the minibuffer. We essentially return all the files in the given directory which have the given prefix.yi-coreLike M-x cd, it changes the current working directory. Mighty useful when we don't start Yi from the project directory or want to switch projects, as many tools only use the current working directory.yi-core*Shows current working directory. Also see .5yi-coreRuns a } action in a separate thread.Notes:%It seems to work but I don't know whyMaybe deadlocks?If you're outputting into the Yi window, you should really limit the rate at which you do so: for example, the Pango front-end will quite happily segfault/double-free if you output too fast.I am exporting this for those adventurous to play with but I have only discovered how to do this a night before the release so it's rather experimental. A simple function that prints a message once a second, 5 times, could be written like this: printer :: YiM ThreadId printer = do mv <- io $ newMVar (0 :: Int) forkAction (suicide mv) MustRefresh $ do c <- io $ do modifyMVar_ mv (return . succ) tryReadMVar mv case c of Nothing -> printMsg "messaging unknown time" Just x -> printMsg $ "message #" <> showT x where suicide mv = tryReadMVar mv >>= case Just i | i >= 5 -> return True _ -> threadDelay 1000000 >> return False yi-core:Prints out the rope of the current buffer as-is to stdout.UThe only way to stop it is to close the buffer in question which should free up the (.yi-corePromptyi-core/Hint transformer: current path, generated hintsyi-coreAction over choice5yi-coreruns after we insert the action: this may be a thread delay or a thread suicide or whatever else; when delay returns False, that's our signal to terminate the thread.yi-core#should we refresh after each actionyi-coreThe action to actually run:GPL-2yi-devel@googlegroups.com experimentalportableNone16]^>"6yi-core.keep track of the num of successful operations7yi-core"if True, DOChoice will be bypassed8yi-core\The full path to the directory being viewed FIXME Choose better data structure for Marks...9yi-core-Map values are just leafnames, not full paths:yi-core'keys are just leafnames, not full paths;yi-core(position in the buffer where filename is<yi-core<position on line where filename is (all pointA are this col)=yi-core:keep the position of pointer (for refreshing dired buffer)>yi-coreHandy alias for ? map.@yi-coreIAlias serving as documentation of some arguments. We keep most paths as 5 for the sole reason that we'll have to render them.Ayi-core^Elementary operations for dired file operations Map a dired mark operation (e.g. delete, rename, copy) command into a list of DiredOps, and use procDiredOp to excute them. Logic and implementation of each operation are packaged in procDiredOp See askDelFiles for example. If new elem op is added, just add corresponding procDiredOp to handle it.Byi-core/remove the buffers that associate with the fileCyi-coreprompt a "yes/no" question. If yes, execute the first list of embedded DiredOps otherwise execute the second list of embedded DiredOpsDyi-coreUsimilar to DOConfirm, but no user interaction. Could be used to check file existenceEyi-core6this is a shortcut, it invokes DCChoice if file existsFyi-coreprompt a string and collect user input. the embedded list of DiredOps is generated based on input, Remember that the input should be checked with DOCheckGyi-core)prompt a string, provide keybindings for y, n, !, q and optional hb (help) this is useful when overwriting of existing files is required to complete the op choice !) will bypass following DOChoice prompts.Hyi-core6to feedback, given the state. such as show the result.Iyi-core no operationyi-coreIf file exists, read contents of file into a new buffer, otherwise creating a new empty buffer. Replace the current window with a new window onto the new buffer.EIf the file is already open, just switch to the corresponding buffer.YNeed to clean up semantics for when buffers exist, and how to attach windows to buffers.Yi.FileC module re-exports this, you probably want to import that instead.KIn case of a decoding failure, failure message is returned instead of the (.Jyi-coreExecute the operationsQPass the list of remaining operations down, insert new ops at the head if neededKyi-core,Delete a list of file in the given directory GAsk for confirmation, if yes, perform deletions, otherwise showNothingbConfirmation is required for recursive deletion of non-empty directry, but only the top level oneBShow the number of successful deletions at the end of the excutionZTODO: ask confirmation for wether to remove the associated buffers when a file is removedLyi-coreUWrite the contents of the supplied directory into the current buffer in dired formatMyi-coreNReturns a tuple containing the textual region (the end of) which is used for clickK detection and the FilePath of the file represented by that textual regionNyi-coreXReturn a List of (prefix, fullDisplayNameIncludingSourceAndDestOfLink, style, filename)Oyi-core?Return dired entries for the contents of the supplied directoryPyi-coreNeeded on Mac OS X 10.4Qyi-coreNeeded on Mac OS X 10.4Ryi-coreGeneric mark toggler.Syi-core!Delete all the keys from the map.Tyi-coreNRemoves mark from current file (if any) and moves in the specified direction.Uyi-coreTmove selected files in a given directory to the target location given by user inputif multiple source then if target is not a existing dir then error else move source files into target dir else if target is dir then if target exist then move source file into target dir else if source is dir and parent of target exists then move source to target else error else if parent of target exist then move source to target else errorVyi-coreTcopy selected files in a given directory to the target location given by user inputhaskCopyFiles follow the same logic as askRenameFiles, except dir and file are done by different DiredOPWyi-corejExtract the filename at point. NB this may fail if the buffer has been edited. Maybe use Markers instead.Ryi-coreeuniversal argument, usually indicating whether to mark or unmark. Here Just &  is taken as unmark.yi-corePicks which entries to consideryi-core7Character used for marking. Pass garbage if unmarking.Tyi-core$Direction to move in after unmarking;GPL-2yi-devel@googlegroups.com experimentalportableNone1]qhyi-core Tries to open a new buffer with @ and runs the given action on the buffer handle if it succeeds.If the , fails, just the failure message is printed.yi-coreSame as openingNewFile with no action to run after.yi-core*Revert to the contents of the file on diskyi-coreaTry to write a file in the manner of vi/vim Need to catch any exception to avoid losing bindingsyi-core4Try to write to a named file in the manner of vi/vimyi-coreGTry to write to a named file if it doesn't exist. Error out if it does. yi-coreFWrite current buffer to disk, if this buffer is associated with a file!yi-core=Write a given buffer to disk if it is associated with a file."yi-core Write current buffer to disk as f. The file is also set to f.#yi-coreWrite all open buffers$yi-coreMake a backup copy of file%yi-core=Associate buffer with file; canonicalize the given path name.&yi-coreChecks if the given buffer deserves a save: whether it's a file buffer and whether it's pointing at a file rather than a directory.Xyi-corekIs there a proper file associated with the buffer? In other words, does it make sense to offer to save it? !"#$%& !#"$%&<GPL-2yi-devel@googlegroups.com experimentalportableNoner''=GPL-2yi-devel@googlegroups.com experimentalportableNoneyi*yi-core1TODO: we're just converting back and forth here, J3 and friends need to migrate to YiString it seems.0yi-core1Open a new buffer for interaction with a process.1yi-coreUopen a new buffer for interaction with a process, using any interactive-derived mode2yi-core$Send the type command to the process3yi-coreSend command, recieve reply ()*+,-./0123 ()*+,-./0123>GPL-2yi-devel@googlegroups.com experimentalportableNone1K]Yyi-core%Cached dictioary for describeNameImplZyi-core*Cached variable for getAllNamesInScopeImpl4yi-core2Config variable for customising the behaviour of 9 and :.Set this variable using <. See  ghciEvaluator and finiteListEvaluator for two implementation.6yi-coreimplementation of 97yi-coreimplementation of :8yi-coreSdescribe named action (or at least its type.), simplest implementation is at least return.9yi-core(Runs the action, as written by the user.CThe behaviour of this function can be customised by modifying the 4 variable.:yi-core,Lists the action names in scope, for use by 9, and help index.CThe behaviour of this function can be customised by modifying the 4 variable.;yi-core0Describes the named action in scope, for use by help.CThe behaviour of this function can be customised by modifying the 4 variable.<yi-coreThe evaluator to use for 9 and :.Fyi-core4Accessor for the published actions. Consider using G.Gyi-corehPublish the given action, by the given name. This will overwrite any existing actions by the same name.Hyi-coreREvaluator based on a fixed list of published actions. Has a few differences from  ghciEvaluator:expressions can't be evaluated)all suggested actions are actually valued@(related to the above) doesn't contain junk actions from Prelude1doesn't require GHCi backend, so uses less memoryIyi-core,Jumps to specified position in a given file.[yi-core'Regex parsing the error message format.\yi-core}Parses an error message. Fails if it can't parse out the needed information, namely filename, line number and column number.]yi-core7Tries to parse an error message at current line using \.Jyi-core1Tries to jump to error at the current line. See ].^yi-coreTries to strip the _ from the front of the given ?. If the prompt is not found, returns the input command as-is.Iyi-coreFilename to make the jump in.yi-coreLine to jump to.yi-coreColumn to jump to.456789:;<FGHIJK9:;45678<HFGJIK`1?GPL-2yi-devel@googlegroups.com experimentalportableNone1K:ayi-core6Dynamic YiVariable to store the help buffer reference.Oyi-coreBDisplays help for a given name, or help index, if no name is givenbyi-core4Finds help text to display, given a command argumentcyi-core(Display help buffer with a given text...OO@GPL-2yi-devel@googlegroups.com experimentalportableNone1KST Vyi-coreqChanging the buffer name quite useful if you have several the same. This also breaks the relation with the file.Wyi-core"shell-command with argument promptXyi-core#shell-command with a known argumentYyi-corecabal-configure\yi-corenRun the given commands with args and pipe the ouput into the build buffer, which is shown in an other window.]yi-core4Run the given command with args in interactive mode.^yi-coreSelect \ or ]% based on stack or cabal command namebyi-core cabal-buildeyi-core'Search the source files in the project.fyi-corePerform a find+grep operationgyi-core stack-buildSTUVWXYZ[\]^_`abcdefghVWXSTUYZ[\]^_`abcdefghANoneedyi-coreList of published ActionsllGPL-2yi-devel@googlegroups.com experimentalportableNoneQVm pyi-coreyAdds the given key bindings to the `global keymap'. The bindings will override existing bindings in the case of a clash.qyi-coremodeBindKeys mode keys adds the keybindings in keys% to all modes with the same name as mode.As with t, a mode by the given name must already be registered, or the function will have no effect, and issue a command-line warning.ryi-coremodeBindKeysByName name keys adds the keybindings in keys to all modes with name name( (if it is registered). Consider using q instead.syi-coreNRegister the given mode. It will be preferred over any modes already defined.tyi-coremodifyMode mode f+ modifies all modes with the same name as mode, using the function f.Note that the mode argument is only used by its 9. In particular, a mode by the given name must already be registered, or this function will have no effect, and issue a command-line warning. t mode f = u (9 mode) fuyi-coremodifyModeByName name f modifies the mode with name name using the function f. Consider using t instead.vyi-coree the font name, or  for default.wyi-coree the font size, or  for default.xyi-core6Amount to move the buffer when using the scroll wheel.yyi-coree the scroll style, or  for default.zyi-coreSee  for documentation.{yi-core(Which side to display the scroll bar on.|yi-coreShould the scroll bar autohide?}yi-coreShould the tab bar autohide?~yi-coreShould lines be wrapped?yi-coreoThe character with which to fill empty window space. Usually '~' for vi-like editors, ' ' for everything else.yi-coreUI colour theme.yi-core Line numbers.yi-core_List of registered layout managers. When cycling through layouts, this list will be consulted.yi-core2Produce a .yi.dbg file with debugging information?yi-corebRun when the editor is started (this is run after all actions which have already been registered)fyi-coreList version of .yi-core~Run after the startup actions have completed, or on reload (this is run after all actions which have already been registered)gyi-coreList version of .yi-core;Actions to run when the editor is started. Consider using  or f instead.yi-core8Actions to run after startup or reload. Consider using  or g instead.yi-coreDefault keymap to use.yi-core?yi-core5List of modes by order of preference. Consider using s, q, or t instead.yi-coreSet to 6 for an emacs-like behaviour. Consider starting with defaultEmacsConfig, defaultVimConfig, or defaultCuaConfig to instead.yi-coreSet to l for an emacs-like behaviour, where all deleted text is accumulated in a killring. Consider starting with defaultEmacsConfig, defaultVimConfig, or defaultCuaConfig instead.yi-core?  #"!&%$('+*).-,10/hijklmnopqrstuvwxyz{|}~2fghijklmnopqrstyvwuxz{|}~ !"#$%&'()*+,/.-0123456789:;<=>?@ABCD    "#($%&')*+,-./23456789:;<=>?@ABCDEFGLMNfghijklmnqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIKLMNOPQRSTUVfhijklmnopqrstuvwxyz{|}~   !"#$%&'()*+,WXYZ[\]^_`abcdefghijklmnopqrstu !"#$%&<FGHlmnopqrstuvwxyz{|}~&pqrstu<HGFvwxyz   mno{|}~  #"!&%$('+*).-,10/fghijklmnopqrstyvwuxz{|}~23456789:;<=>?@ABCDEFGLMNfghijklmnqrstuvwx      !"#$%&'()*+,-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIKLMNOPQRSTUV    KGPL-2yi-devel@googlegroups.com experimentalportableNone  #"!&%$('+*).-,10/hijklmnopqrstuvwxyz{|}~2fghijklmnopqrstyvwuxz{|}~     "#($%&')*+,-./23456789:;<=>?@ABCDEFGLMNfghijklmnqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIKLMNOPQRSTUVfhijklmnopqrstuvwxyz{|}~   !"#$%&'()*+,WXYZ[\]^_`abcdefghijklmnopqrstu !"#$%&456789:;<FGHIJKlLMNOPQOPROPSOPTOPUOVWOVXOVYOVZOVZO[\O[]O[^O[_O[`O[aO[bO[cO[dO[eO[fO[gO[hO[iO[jO[kO[lO[mO[nOopOoqOorOosOotOouOovOowOowOoxOoxOoyOozOozOo{Oo|Oo|Oo}Oo~Oo~O GGGGGGGGGGGGGGGGGGGGGGGG               !"#$%&'()*+,-./0123456789:;<=>?@ABCDDEFGHIJKLMNOPQRSTUVWXYZ[\]]^_`aabcdeffghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./01234567889:;<=>?@ABCDEFGHIJKLMMNOPQRSTUVWXYZ[\]^^_``abcdefghijklmnHopqrIIsJtuvwxyz{|}~KK        !!!!!!!!!! !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~""""""""""""#######################################################$$$$$$%%%%%%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%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%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u&v&w&x&y&z&{&|&}&~&&&'''''''''(((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))*********+++++++++++++++r+r++++++,,,,,,,,,,,,,,,,, , , , , ,,,,,,,,,---....... /!/"/&/#/$/%/&/'/(/)/*/+/,/-/.///0/1/2/3/4/5/6/7/8090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M1N1O1P1Q1R2S2T2U2V2W2X2Y3Z3Z3[3\3]3^3^3_3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3uvwxyz{|}~4444444444445555555555555555566666666666666667777777777777777777777777777777777777777777777777788888888 8 8 8 9 99999999999999::::: :!:":#:$:%:&:':(:):*:+:,:-:.:/:0:1:2:3;4;5;6;7;8;9;:;;;<;=;>;?;@;A;B;C<D=D=E=F=G=H=I=J=K=L=M=N=O>P>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@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}@~@@@@@@@AiE;<=DBBBCCCCDDDDDDGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG           "###### %!%"%#%$%%%&'%(%)%*%+%,&-&.&/&0&1&234&5O67)8)9):;<=4>4?@A@BC5D6E6F6G6H6I6J6K6L6M7N7O8POVQO6ROVS9T9U: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>{>|>}>~>>???AOOOO6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6O6%yi-core-0.18.0-2mRGjmA9uZSHB9MvTT6v9UYi.MonadYi.Buffer.Misc Yi.SearchYi.IncrementalParseYi.Config.Simple Yi.CompletionParser.Incremental Paths_yi_coreSystem.FriendlyPath Yi.BufferYi.Buffer.UndoYi.CompletionTreeYi.Config.MiscYi.DebugYi.Event Yi.Interact Yi.JumpList Yi.KillRing Yi.LayoutYi.Paths Yi.Process Yi.StringYi.Syntax.LayoutYi.Syntax.TreeYi.Syntax.OnlineTreeYi.Syntax.Driver Yi.UI.Common Yi.WindowYi.TabYi.TypesYi.Config.Lens Yi.ConfigYi.Config.Simple.TypesYi.Buffer.RegionYi.Buffer.TextUnitYi.Buffer.NormalYi.Buffer.HighLevelYi.Buffer.Indent Yi.UI.UtilsYi.UI.LineNumbers Yi.Editor Yi.UI.TabBarYi.UI.SimpleLayoutYi.TagYi.Search.Internal Yi.Rectangle Yi.KeymapYi.Keymap.KeysYi.Hooks Yi.Hoogle Yi.HistoryYi.PersistentStateYi.TextCompletionYi.Core Yi.MiniBufferYi.Mode.CommonYi.MiscYi.DiredYi.FileYi.Mode.CompilationYi.Mode.InteractiveYi.EvalYi.Command.Help Yi.CommandYi.Config.Default Control.ExcData.DelayListSystem.CanonicalizePathTfilterYi.Buffer.ImplementationIndentBehaviourMode modeAppliesYi mtl-2.2.2Control.Monad.State.Classgets)yi-language-0.18.0-1FEc2siMQfF3fsxTbsKtHEYi.Regex SearchExp QuoteRegex NoNewLine IgnoreCase SearchOption Yi.Lexer.AlexstPosn lookedOffsetstLexer AlexState Yi.RegionregionsOverlap regionIsEmptyincludedRegion nearRegioninRegion emptyRegion mkSizeRegion mkRegion'mkRegion unionRegionintersectRegion regionSize fmapRegion regionLast regionFirst regionEnd regionStartregionDirectionRegionYi.Buffer.Basic directionElim mayReverse reverseDirForwardBackward DirectionmarkIdMark BufferRef fromPointPointfromSizeSize unWindowRef WindowRefYi.Utils commonPrefixProcessLogEntryLLogLEmptyLDislikeLShiftLDoneLFailLSuspLSParserLookYuckEnterprofile countWidthsymboleoffeedZevalLevalL'pushSymspushEof mkProcessruntestNextlookNext recoverWithevalRfullLog $fMonadParser$fAlternativeParser$fApplicativeParser$fFunctorParser $fShowSteps $fShowRPolish $fShowZip$fShowProfileF$fFunctorProfileF$fShowLogEntryversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameuserToCanonPath expandTilda isAbsolute' MarkValue markPoint markGravityUIUpdate TextUpdate StyleUpdateUpdateInsertDelete updatePointupdateDirection_insertUpdateString_deleteUpdateStringOverlay overlayOwner overlayBegin overlayEnd overlayStyleoverlayAnnotation markGravityAA markPointAAupdateIsDelete mkOverlayURListChangeInteractivePoint AtomicChangeemptyU addChangeUdeleteInteractivePointsUsetSavedFilePointUundoUredoUisAtSavedFilePointU$fBinaryChange$fBinaryURList $fShowChange$fGenericChange $fShowURList$fGenericURListCompletionTreeunCompletionTreefromListcompleteupdatetoListpretty$fShowCompletionTree$fSemigroupCompletionTree$fMonoidCompletionTree$fEqCompletionTree$fBinaryCompletionTree ScrollStyle SnapToCenter SingleLine initDebugtraceerror logPutStrLnlogError logStreamtraceMtraceM_EventKeyKEscKFunKPrtScrKPauseKASCIIKBSKInsKHomeKPageUpKDelKEnd KPageDownKNP5KUpKMenuKLeftKDownKRightKEnterKTabModifierMShiftMCtrlMMetaMSuperMHyper prettyEvent eventToChar $fShowEvent $fOrdEvent$fShowModifier $fEqModifier $fOrdModifier$fEqKey $fShowKey$fOrdKey $fEqEventStatePscanner InteractState AmbiguousWaitingDeadRunningEndChainI MonadInteractwrite eventBoundsadjustPriority deprioritize<||||> importantacceptedrunWriteprocessOneEvent computeStateoneOfanyEvent eventBetweeneventeventschoiceoption mkAutomaton idAutomaton$fMonadInteractStateTwe$fMonadInteractIwevent $fMonadPlusI$fMonadI$fAlternativeI$fApplicativeI $fFunctorI$fShowP$fMonoidInteractState$fSemigroupInteractStateJumpjumpMark jumpBufferRefJumpListaddJumpjumpBack jumpForward $fShowJump $fBinaryJump $fGenericJumpKillring _krKilled _krContents$fBinaryKillring$fShowKillring $fEqKillring krContentskrKilled krLastYankkrEmptykrEndCmdkrPutkrSetkrGetLayoutM Transposed Transposable transposeHasNeighborWest RectanglerectXrectY rectWidth rectHeightAnyLayoutManager LayoutManager pureLayoutdescribeLayout nextVariantpreviousVariant RelativeSizeDividerPosition DividerRef Orientation HorizontalVerticalLayout SingleWindowStackPair orientationwinsdivPosdivRefpairFstpairSnddividerPositionA findDividerlayoutManagerSameTypetallwide slidyTall slidyWide hPairNStack vPairNStacklayoutToRectangles singleWindowpairstack evenStack runLayoutM$fDefaultLayout $fShowLayout$fDefaultAnyLayoutManager$fLayoutManagerAnyLayoutManager$fEqAnyLayoutManager$fLayoutManagerTall$fLayoutManagerWide$fLayoutManagerSlidyTall$fLayoutManagerHPairNStack$fTransposableLayout$fTransposableOrientation$fLayoutManagerTransposed$fLayoutManagerVPairNStack$fLayoutManagerSlidyWide$fEqOrientation$fShowOrientation $fEqLayout$fFunctorLayout$fEqTall$fEqWide $fEqSlidyTall$fEqHPairNStack $fEqRectangle$fShowRectangle$fEqTransposed$fEqVPairNStack $fEqSlidyWide getsAndModifywithwhenMmaybeM repeatUntilMassignuses getConfigDir getDataPath getConfigPathgetCustomConfigPathgetConfigFilenamegetConfigModulesgetPersistentStateFilenamegetEvaluatorContextFilenameSubprocessInfoprocCmdprocArgs procHandlehInhOuthErrbufRefseparateStdErr SubprocessIdrunProgCommand shellFileNamerunShellCommandcreateSubprocess readAvailableshowTlistify commonTPrefixcommonTPrefix' capitalizecapitalizeFirstchomp dropSpaceisBlankfillTextoverInitoverTailunlines'lines'mapLinesonLinespadLeftpadRight layoutHandler$fShowBlockOpen $fShowIStateIsTreesubtreesuniplate emptyNode toksAfterallToks tokAtOrBefore toksInRegiontokenBasedAnnotstokenBasedStrokesfromNodeToFinalfromLeafToLeafAfter getLastPathgetAllSubTreesgetFirstElementgetLastElementgetFirstOffset getLastOffset subtreeRegionsepBysepBy1TreeBinLeafTipmanyToks $fIsTreeTree $fShowTree $fFunctorTree$fFoldableTree$fTraversableTreeCachepath cachedStatesrootfocusedPath mkHighlighterunzipFM zipWithFMUImainendsuspendrefreshuserForceRefreshlayout reloadProjectdummyUIWindowisMinibufkey bufAccessListheightwidth winRegionwkey actualLinesjumpList actualLinesAbufAccessListAbufkeyAheightAisMiniA jumpListAwidthA winRegionAwkeyAwinkey dummyWindow $fEqWindow $fShowWindow$fBinaryWindowTabtkey tabLayoutTabReftabFocustabMiniWindows tabWindowsAtabLayoutManagerAtabDividerPositionA mapWindowsforceTabtabFoldlmakeTabmakeTab1 $fShowTab$fEqTab $fBinaryTab RegionStyleLineWise Inclusive ExclusiveBlockConfig startFrontEndconfigUI startActionsinitialActions defaultKmconfigInputPreprocess modeTable debugModeconfigRegionStyleconfigKillringAccumulate%configCheckExternalChangesObsessivelybufferUpdateHandlerlayoutManagers configVars CursorStyle AlwaysFatNeverFatFatWhenFocusedFatWhenFocusedAndInsertingUIBootUIConfigconfigFontNameconfigFontSizeconfigScrollStyleconfigScrollWheelAmountconfigLeftSideScrollBarconfigAutoHideScrollBarconfigAutoHideTabBarconfigLineWrapconfigCursorStyleconfigWindowFill configThemeconfigLineNumbers MonadEditoraskCfg withEditor withEditor_EditorM fromEditorMEditor bufferStackbuffers refSupplytabs_dynamic statusLinesmaxStatusHeightkillring currentRegexsearchDirection pendingEventsonCloseActionsStatusesStatus IncreaseCycle DecreaseCycle IncreaseOnly DecreaseOnlymodeNamemodeHL modePrettify modeKeymap modeIndent modeFollowmodeIndentSettingsmodeToggleCommentSelectionmodeGetStrokes modeOnLoad modeModeLinemodeGotoDeclarationAnyModeSelectionStylehighlightSelectionrectangleSelectionBufferId MemBuffer FileBuffer Attributesidentbkey__undos bufferDynamic preferCol preferVisCol stickyEolpendingUpdatesselectionStyle keymapProcesswinMarkslastActiveWindow lastSyncTimereadOnly insertingdirectoryContentpointFollowsWindowupdateTransactionInFlightupdateTransactionAccumfontsizeVariation updateStreamMarkSetfromMarkinsMarkselMarkWinMarksFBufferbmoderawbuf attributesIndentSettings expandTabstabSize shiftWidthBufferM fromBufferM KeymapSet topKeymap insertKeymapYiMrunYiMYiVaryiEditoryiSubprocessIdSupplyyiSubprocessesyiUiyiInputyiOutputyiConfigyiVarIsRefreshNeeded MustRefreshNoNeedToRefresh KeymapProcess KeymapEndoKeymapKeymapMInteractYiConfigVariable YiVariableActionYiAEditorABufferA emptyActionunsafeWithEditorextractTopKeymap runEditor$fBinaryMarkSet$fBinaryBufferId$fBinarySelectionStyle$fYiVariableRegionStyle$fDefaultRegionStyle$fBinaryRegionStyle$fBinaryAttributes $fEqFBuffer$fApplicativeBufferM$fMonadStateEditorYiM $fShowAction $fEqAction$fMonadEditorEditorM$fMonadEditorYiM$fShowIsRefreshNeeded$fEqIsRefreshNeeded$fEqIndentSettings$fShowIndentSettings$fTraversableMarkSet$fFoldableMarkSet$fFunctorMarkSet $fShowMarkSet$fShowBufferId $fEqBufferId $fOrdBufferId$fShowSelectionStyle$fEqIndentBehaviour$fShowIndentBehaviour$fEqRegionStyle$fShowRegionStyle$fMonadEditorM$fApplicativeEditorM$fMonadStateEditorM$fMonadReaderEditorM$fFunctorEditorM$fMonadBufferM$fFunctorBufferM$fMonadStateBufferM$fMonadReaderBufferM $fMonadYiM$fApplicativeYiM$fMonadReaderYiM$fMonadBaseYiM $fFunctorYiMbufferUpdateHandlerA&configCheckExternalChangesObsessivelyAconfigInputPreprocessAconfigKillringAccumulateAconfigRegionStyleA configUIA configVarsA debugModeA defaultKmAinitialActionsAlayoutManagersA modeTableA startActionsAstartFrontEndAconfigAutoHideScrollBarAconfigAutoHideTabBarAconfigCursorStyleAconfigFontNameAconfigFontSizeAconfigLeftSideScrollBarAconfigLineNumbersAconfigLineWrapAconfigScrollStyleAconfigScrollWheelAmountA configThemeAconfigWindowFillAconfigVariable configStyleconfigFundamentalModeconfigTopLevelKeymapFieldConfigM runConfigMcustomVariable$fMonadConfigM$fFunctorConfigM$fApplicativeConfigM$fMonadStateConfigM$fMonadBaseConfigMdirectoryContentAfontsizeVariationAidentA insertingAkeymapProcessAlastActiveWindowA lastSyncTimeApendingUpdatesApointFollowsWindowA preferColA readOnlyA stickyEolAundosAshortIdentString identStringminiIdentString clearSyntaxfilehighlightSelectionArectangleSelectionAincreaseFontSizedecreaseFontSize getModeLine getPercent queryBuffer addOverlayBgetOverlaysOfOwnerB delOverlayBdelOverlaysOfOwnerBisPointInsideOverlay runBuffergetMarks runBufferFull getMarkValueBnewMarkB deleteMarkBrunBufferDummyWindow markSavedBbkeyisUnchangedBufferstartUpdateTransactionBcommitUpdateTransactionBundoBredoBretroactivelyAtSavePointBmodeAlwaysAppliesmodeNeverApplies emptyModenewBsizeBpointBnelemsBstreamBindexedStreamBstrokesRangesBmoveTo setInserting applyUpdaterevertPendingUpdatesBwriteBwriteNnewlineB insertNAtinsertNinsertB deleteNAtcurLn screenTopLn screenMidLn screenBotLn markLinesgotoLnsetMode0 setAnyModesetMode modifyModeonMode withMode0 withModeB withSyntaxB focusSyntax withSyntaxB' regexRegionBregexB modifyMarkB setMarkHereBsetNamedMarkHereBsetVisibleSelectiongetVisibleSelectionaskMarksgetMarkB mayGetMarkBmoveNleftBleftNrightBrightN lineMoveRelmovingToPrefColmovingToPrefVisCol moveToColBmoveToLineColBpointOfLineColBforgetPreferCol savingPrefCollineUplineDownelemsBbetweenBreadBreadAtB replaceCharBreplaceCharWithBelowBreplaceCharWithAboveBinsertCharWithBelowBinsertCharWithAboveBdeleteNindentSettingsBcurColcolOflineOf lineCountB solPointB eolPointB gotoLnFrom getBufferDyn putBufferDynsavingExcursionB markPointA savingPointBsavingPositionBpointAtpointAfterCursorBdestinationOfMoveB askWindowwithEveryLineB $fBinaryMode$fBinaryFBuffer $fShowFBuffer$fHasAttributesFBuffer$fHasAttributesAttributes expandTabsA shiftWidthAtabSizeA modeAppliesA modeFollowAmodeGetStrokesAmodeGotoDeclarationAmodeHLA modeIndentAmodeIndentSettingsA modeKeymapA modeModeLineA modeNameA modeOnLoadA modePrettifyAmodeToggleCommentSelectionA winRegionB deleteRegionB readRegionBreplaceRegionB mapRegionB swapRegionsB modifyRegionBinclusiveRegionBblockifyRegion joinLinesB concatLinesBlinesOfRegionB BoundarySide InsideBound OutsideBoundTextUnit CharacterLineVLineDocumentGenUnitgenEnclosingUnitgenUnitBoundary outsideUnitunitWord unitDelimited isWordChar checkPeekB unitViWord unitViWORDunitViWordAnyBndunitViWORDAnyBndunitViWordOnLineunitViWORDOnLineisAnySepunitSepunitSepThisLine atBoundaryBunitEmacsParagraph unitParagraph unitSentenceleftBoundaryUnitgenAtBoundaryB numberOfBwhileBuntilB doUntilB_untilB_ doIfCharBgenMoveB genMaybeMoveBmoveB maybeMoveB transposeB transformBdeleteBregionWithTwoMovesB regionOfBregionOfNonEmptyB regionOfPartBregionOfPartNonEmptyBregionOfPartNonEmptyAtB readPrevUnitB readUnitBhalfUnit deleteUnitB$fEqBoundarySidegetRegionStyleputRegionStyleconvertRegionToStyleBmkRegionOfStyleBunitWiseRegionextendRegionToBoundariesBufferFileInfobufInfoFileName bufInfoSize bufInfoLineNo bufInfoColNo bufInfoCharNobufInfoPercentbufInfoModified moveToMTB moveToSol moveToEoltopBbotB leftOnEol moveXorSol moveXorEol nextWordB prevWordBgotoCharacterBnextCIncnextCInLineIncnextCExcnextCInLineExcprevCIncprevCInLineIncprevCExcprevCInLineExcfirstNonSpaceB lastNonSpaceBmoveNonspaceOrSolisCurrentLineEmptyBisCurrentLineAllWhiteSpaceBnextNParagraphsprevNParagraphsselectNParagraphsatSolatEolatSofatEof atLastLine getLineAndColgetLineAndColOfPointreadLnBhasWhiteSpaceBeforereadCurrentWordB readPrevWordBbdeleteB killWordB bkillWordB bdeleteLineBdeleteHorizontalSpaceBuppercaseWordBlowercaseWordBcapitaliseWordBswitchCaseChar deleteToEolswapBdeleteTrailingSpaceBsetSelectionMarkPointBgetSelectionMarkPointBexchangePointAndMarkB getBookmarkBbufInfoB upScreensB downScreensB upScreenB downScreenBscrollScreensB vimScrollB vimScrollByBscrollToCursorBscrollCursorToTopBscrollCursorToBottomBscrollBscrollToLineAboveWindowBscrollToLineBelowWindowBsnapInsB snapScreenB downFromTosB upFromBosBmiddleBgetRawestSelectRegionBgetSelectRegionBsetSelectRegionBdeleteBlankLinesB lineStreamB getNextLineBgetNextNonBlankLineBmodifyExtendedSelectionBlinePrefixSelectionBunLineCommentSelectionBtoggleCommentBreplaceBufferContent fillParagraph sortLinessortLinesWithRegionrevertBshapeOfBlockRegionBleftEdgesOfRegionBrightEdgesOfRegionB'splitBlockRegionToContiguousSubRegionsBdeleteRegionWithStyleBreadRegionRopeWithStyleBinsertRopeWithStyleBflipRectangleBmovePercentageFileBfindMatchingPairBincrementNextNumberByB isNumberB test3CharBtestHexBlineMoveVisRelmarkWord$fShowRelPositiontabB autoIndentB cycleIndentsB indentOfB indentToB modifyIndentBindentAsPreviousB indentAsNextB$indentAsTheMostIndentedNeighborLineBnewlineAndIndentBshiftIndentOfRegionBindentOfCurrentPosB applyHeights spliceAnnots strokePicture paintStrokes paintPictureattributesPictureBattributesPictureAndSelB arrangeItems arrangeItems'getDisplayLineNumbersLocalsetDisplayLineNumbersLocal#$fYiVariableDisplayLineNumbersLocal$fBinaryDisplayLineNumbersLocal $fDefaultDisplayLineNumbersLocal $fGenericDisplayLineNumbersLocal emptyEditor$fBinaryEditorbuffersA currentRegexA killringAmaxStatusHeightAonCloseActionsApendingEventsAsearchDirectionA statusLinesAwindowswindowsAtabsAaskConfigVariableAstringToNewBuffer deleteBuffer bufferSetcommonNamePrefixgetBufferStack findBufferfindBufferWithfindBufferWithNamedoesBufferNameExistgetBufferWithNamewithGivenBufferwithGivenBufferAndWindowwithCurrentBufferwithEveryBuffercurrentWindowA currentBufferprintMsg printMsgs printStatus setStatus clrStatus statusLinestatusLineInfosetRegEgetRegE getEditorDyn putEditorDyn newBufferEnewEmptyBufferEalternateBufferE newWindowEswitchToBufferEswitchToBufferWithNameE closeBufferEgetBufferWithNameOrCurrentcloseBufferAndWindowEnextWinEprevWinEswapWinWithFirstEpushWinToFirstE moveWinNextE moveWinPrevE withWindowEfindWindowWithwindowsOnBufferE focusWindowEsplitElayoutManagersPrintMsgElayoutManagersNextElayoutManagersPreviousElayoutManagerNextVariantElayoutManagerPreviousVariantEsetDividerPosEnewTabEnextTabE previousTabEmoveTabE deleteTabE tryCloseE closeOtherEshiftOtherWindowwithOtherWindowacceptedInputsOtherWindow addJumpHereE addJumpAtE jumpBackE jumpForwardEnewTempBufferE TabBarDescrTabDescrtabText tabInFocus tabBarDescrtabAbbrevTitle$fShowTabDescr $fEqTabDescrSize2D sizeWidth sizeHeightPoint2DpointColpointRowRectoffsetXoffsetYsizeXsizeY tabbarRect windowRects promptRectcoordsOfCharacterBverticalOffsetsForWindows$fYiConfigVariableTagsFileList$fDefaultTagsFileListTagTable tagFileName tagBaseDir tagFileMaptagCompletionTreeTag_unTag tagsFileListunTag' lookupTag readCTagsimportTagTablehintTags completeTagsetTags resetTagsgetTags$fBinaryTagTable$fYiVariableTags $fDefaultTags $fShowTag$fEqTag$fOrdTag $fBinaryTag$fGenericTagTable $fBinaryTags setRegexE resetRegexE getRegexE getRectangle multiSplit onRectangle openRectanglestringRectangle killRectangle yankRectangleYiAction makeActionwithUI readEditor catchDynE catchJustE handleJustE$fYiActionAction()$fYiActionBufferMx$fYiActionEditorMx$fYiActionYiMx $fYiActionIOx insertKeymapA topKeymapAmodelessKeymapSet withModeY yiEditorAyiSubprocessIdSupplyAyiSubprocessesA yiConfigAyiInputA yiOutputAyiUiAyiVarA printableChartextCharpStringcharOfshiftctrlmetasuperhypercharctrlChmetaChhyperChoptModspec>>!>>=!?>>?>>!?*>>?*>>!HookTyperunHook$fHookType(->) $fHookTypeYiM$fHookTypeEditorM caseSensitizegv hoogleRawhoogleFunctionshoogleFunModulehoogle hoogleSearchHistory_historyCurrent_historyContents_historyPrefix HistoriesdynKeyA miniBuffer historyUp historyDown historyStarthistoryStartGen historyFinishhistoryFinishGen historyFind historyMovehistoryMoveGenhistoryPrefixSethistoryPrefixSet' setHistory$fBinaryHistory$fDefaultHistory$fYiVariableHistories$fDefaultHistories$fBinaryHistories $fShowHistory $fEqHistory$fShowHistories $fEqHistories SearchResult PatternFoundPatternNotFound SearchWrapped SearchMatchdoSearch searchInitcontinueSearchsearchReplaceRegionBsearchReplaceSelectionB replaceStringsearchAndRepRegion0searchAndRepRegionsearchAndRepUnit isearchInitEisearchIsEmpty isearchAddEmakeSimpleSearch isearchDelEisearchHistory isearchPrevE isearchNextE isearchWordEisearchFinishEisearchCancelEisearchFinishWithEisearchCancelWithEqrNext qrReplaceAllqrFinish qrReplaceOne$fYiVariableIsearch$fDefaultIsearch$fBinaryIsearch$fEqSearchResult $fShowIsearch$fBinaryPersistentState#$fYiConfigVariableMaxHistoryEntries$fDefaultMaxHistoryEntries$fGenericPersistentState$fBinaryMaxHistoryEntriesmaxHistoryEntries"$fYiConfigVariablePersistentSearch$fDefaultPersistentSearch$fBinaryPersistentSearchpersistentSearchsavePersistentStateloadPersistentStateisCasePrefixOf prefixMatchinfixUptoEndMatchsubsequenceMatchsubsequenceTextMatchcontainsMatch' containsMatchcontainsMatchCaseInsensitivecompleteInListcompleteInListCustomShowcompleteInList'CompletionScopeFromCurrentBufferFromAllBuffers resetCompletemkWordCompletewordCompleteString'wordCompleteString wordComplete' wordComplete completeWordB$fYiVariableCompletion$fDefaultCompletion$fBinaryCompletion$fShowCompletion$fEqCompletion$fEqCompletionScope$fShowCompletionScope startEditor quitEditorquitEditorWithExitCodefocusAllSyntax refreshEditor suspendEditorrunProcessWithInput runAction errorEditor closeWindowcloseWindowEmacsonYiVarstartSubprocess sendToProcess withSyntaxCommandArgumentsFilePatternTagRegexTagToKill LineNumber:::DocfromDocpromptingForBuffer commentRegionspawnMinibufferEwithMinibuffer mkCompleteFnsimpleCompleteinfixComplete' infixCompletenoHintnoPossibilitieswithMinibufferFreewithMinibufferGenwithMinibufferFin anyModeNameanyModeByNameM anyModeByNamegetAllModeNamesmatchingBufferNames$fYiAction(->)x$fPromptableBufferRef$fPromptableAnyMode$fPromptablePoint$fPromptableTextUnit$fPromptableDirection$fPromptableYiString$fPromptableText$fPromptableInt$fPromptableChar$fPromptable[] $fShow:::$fPromptable:::$fDocTypeLineNumber$fDocTypeToKill$fDocTypeRegexTag$fDocTypeFilePatternTag$fPromptableCommandArguments$fEq:::$fNum::: $fIsString:::$fShowCommandArguments$fEqCommandArgumentsTokenBasedModefundamentalModelinearSyntaxMode styleModeextensionMatches anyExtensionextensionOrContentsMatch shebangParser hookModesapplyModeHooks lookupModegetAppropriateFiles getFoldermatchingFileNames placeMark selectAll adjIndent promptFilepromptFileChangingHints matchFile completeFilecdpwd rot13CharprintFileInfoEdebugBufferContent$fYiVariableDiredOpState$fBinaryDiredOpState$fDefaultDiredOpState$fShowDiredOpState$fEqDiredOpState$fGenericDiredOpState$fShowDiredFileInfo$fEqDiredFileInfo$fGenericDiredFileInfo$fShowDiredEntry$fEqDiredEntry$fGenericDiredEntry$fShowDiredState$fEqDiredState$fGenericDiredStateeditFiledireddiredDirdiredDirBuffer$fBinaryDiredFileInfo$fBinaryDiredEntry$fYiVariableDiredState$fDefaultDiredState$fBinaryDiredState$fYiConfigVariablePreSaveHooks$fDefaultPreSaveHooks preSaveHooksopeningNewFile openNewFilerevertEviWrite viWriteTo viSafeWriteTofwriteE fwriteBufferE fwriteToE fwriteAllYbackupE setFileName deservesSavemode interactIdinteractHistoryMoveinteractHistoryFinishinteractHistoryStartgetInputRegiongetInputsetInput spawnProcessspawnProcessMode feedCommand queryReply EvaluatorexecEditorActionImplgetAllNamesInScopeImpldescribeNamedActionImplexecEditorActiongetAllNamesInScopedescribeNamedAction evaluator$fYiVariableNamesCache$fDefaultNamesCache$fYiVariableHelpCache$fDefaultHelpCache$fDefaultPublishedActions$fBinaryNamesCache$fBinaryHelpCache$fSemigroupPublishedActions$fMonoidPublishedActionspublishedActions publishActionpublishedActionsEvaluatorjumpToE jumpToErrorE consoleKeymap$fYiConfigVariableEvaluator$fDefaultEvaluator"$fYiConfigVariablePublishedActionsdisplayHelpFor$fYiVariableHelpBuffer$fDefaultHelpBuffer$fBinaryHelpBuffer CabalBuffer cabalBufferchangeBufferNameE shellCommandE shellCommandVcabalConfigureE configureExitreloadProjectEbuildRuninteractiveRun selectRunner makeBuildcabalRunmakeRun cabalBuildE makeBuildEshell searchSourcesgrepFind stackCommandEstackRun$fYiVariableCabalBuffer$fDefaultCabalBuffer$fBinaryCabalBuffer defaultConfigSideLeftSide RightSideglobalBindKeys modeBindKeysmodeBindKeysByNameaddModemodifyModeByNamefontNamefontSizescrollWheelAmount scrollStyle cursorStyle scrollBarSideautoHideScrollBarautoHideTabBarlineWrap windowFilltheme lineNumbersdebug runOnStartuprunAfterStartupinputPreprocessmodes regionStylekillringAccumulateignoringExceptionprintingException orException-? DelayListinsertdecreaseStepsbetterevalR'iBestfeed:<canonicalizePath expandSym makeAbsolute combinePath splitPathbase Data.FoldableelemreplaceShorthandsmemmarkshlCacheoverlays dirtyOffsetnewBI insertChars deleteCharsshiftMarkValuesizeBInelemsBIgetIndexedStream overlayUpdate addOverlayBI delOverlayBIstrokesRangesBI isValidUpdate applyUpdateIreverseUpdateIlineAtsolPoint eolPoint' solPoint' regexRegionBI modifyMarkBIgetMarkDefaultPosBI BufferImpl markNames getStreamdelOverlaysOfOwnerBIgetOverlaysOfOwnerBIcharsFromSolBI newMarkBIgetMarkValueBIdeleteMarkValueBI getMarkBI setSyntaxBI updateSyntaxgetAstfocusAstundoInteractiveremIPaddIPundoUntilInteractiveasRedo maximumBy' pushEvent findWritespush HPairNStack SlidyWide SlidyTallWideTallGHC.BaseidNothingGHC.Showshow text-1.2.3.0Data.Text.InternalText Text.Readread#yi-rope-0.11-JRS9ahQFc2YDSX1eUvsD8eYi.Ropeinitlasttailhead Data.OldListunlineslinespruneNodesBefore firstThatlastThatfromLeafAfterToFinalallLeavesRelative'nodesAndChildIndexallLeavesRelativeChild allLeavesIn getAllPathsgetSubtreeSpan tabWindowstabLayoutManager buildLayoutghc-prim GHC.TypesTrueString.const2YiString singleton screenLines curVisColcolMove nextRegion genBoundaryisEndOfSentencechecksFalsefirstTwo atBoundarydoUntilBreadPreviousOfLnB prevPointBindexOfSolAbovepointScreenRelPositiongetRawSelectRegionBgetMaybeNextLineBMaybegetNextLineWhichBtoggleCommentSelectionB fillRegionmodifyExtendedLRegion incrementautoIndentHelperBfetchPreviousIndentsBlastOpenBracketHint spacingOfB rePadString countIndent GHC.UnicodeisSpace indentStringYi.Style defaultStylenewZeroSizeWindowfixCurrentBufferA_ withLMStackEisearchEndWith isearchEndqrReplaceCurrent trimHistoriesreadPersistentState Data.Text isPrefixOf toCaseFold bestMatch Completion interactive showErrorsdispatchcheckFileChangesclearAllSyntaxAndHideSelection msgEditorterminateSubprocessesappendToBufferstartSubprocessWatchers typeGetPromptcompletionFunctionlinearSyntaxMode'Lexer StyleName commonLexer findFileHint forkAction_diredOpSucCnt_diredOpForAll diredPath diredMarks diredEntriesdiredFilePoints diredNameCol diredCurrFile DiredEntries DiredEntry DiredFilePathDiredOpDORemoveBuffer DOConfirmDOCheck DOCkOverwriteDOInputDOChoice DOFeedbackDONoOp procDiredOp askDelFiles diredRefreshinsertDiredLinelinesToDisplay diredScanDir scanForUid scanForGid diredMarkKind deleteKeys diredUnmarkaskRenameFiles askCopyFiles fileFromPoint isFileBuffer HelpCache NamesCache errorRegexparseErrorMessageparseErrorMessageB takeCommandprompt<&> HelpBufferhelpFordisplayHelpBufferdefaultPublishedActionsJustrunManyOnStartuprunManyAfterStartupYi.Style.Library darkBlueTheme defaultThemeTheme brightwhitewhitecyandarkcyanmagentapurplebluedarkblueyellowbrowngreen darkgreenreddarkred lightGreygreyblack colorToText withReverse withUnderlinewithItlcwithBdwithBgwithFgemptyAttributes foreground background reverseAttrbolditalic underlineStyleUIStylemodelineAttributesmodelineFocusStyletabBarAttributestabInFocusStyletabNotFocusedStylebaseAttributes selectedStyleeofStyle errorStyle hintStylestrongHintStyle commentStyleblockCommentStyle keywordStyle numberStylepreprocessorStyle stringStylelongStringStyle typeStyledataConstructorStyle importStyle builtinStyle regexStyle variableStyle operatorStyle quoteStylemakeFileActionmakeFileRuleHeadColorDefaultRGB,oo-prototypes-0.1.0.0-CjLM0asobWA3HIAtkJIgOxData.Prototype.->override extractValueProto fromProto