j&_      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno p q r s t u v w x y z { | } ~                                   !"# $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^None,!_`abcdefghijklmnopqrstuvwxyz{|}~((General Exceptions(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone1]4)Exceptions specific to nvim-hs.*bSimply error message that is passed to neovim. It should currently only contain one line of text.+;Error that can be returned by a remote API call. A call of  fromObject1 on this value could be converted to a value of NeovimExceptionGen.)*+,)*+,)*+=Type classes used for conversion of msgpack and Haskell types(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone ;<=>?QV]E'0Conversion from J files to Haskell types and back with respect to neovim's interpretation.The  constraint has been added to allow forcing results of function evaluations in order to catch exceptions from pure code. This adds more stability to the plugin provider and seems to be a cleaner approach.5A generic vim dictionary is a simply a map from strings to objects. This type alias is sometimes useful as a type annotation especially if the OverloadedStrings extension is enabled.6(Convenient operator to create a list of  from normal values. T values +: of :+ different :+ types :+ can +: be +: combined +: this +: way +: [] 7 Convert a  -ument to a messagepack . This is more a convenience method to transport error message from and to neovim. It generally does not hold that 'docToObject . docFromObject' = .8See 7.F#Right-biased instance for toObject.'      #"!%01324567890123456789 %#""!0123465)P.Parser for the msgpack output stram API(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneQR X9This data type represents the top-level structure of the nvim --api-info output.Z8The error types are defined by a name and an identifier.["Extension types defined by neovim.\=The remotely executable functions provided by the neovim api.]UThis data type contains simple information about a function as received throudh the nvim --api-info command._ function name`&A list of type name and variable name.a:Indicator whether the function can fail/throws exceptions.b4Indicator whether the this function is asynchronous.cFunctions return type.hRun nvim --api-info and parse its output.XYZ[\]^b_`acdgefhXYZ[\]^_`abcdefghXYZ[\]^_`abcdefgLogging utilities and reexports(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNoneWmDisable logging to stderr.nInitialize the root logger to avoid stderr and set it to log the given file instead. Simply wrap the main entry point with this function to initialze the logger. main = n "/home/dude/nvim.log" Debug $ do  "Hello, World!" # !"#$%&'()*+,-./0123 mnmn )Classes and data types related to plugins(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone"#6]o5Conveniennce class to extract a name from some value.q5Options that can be used to register an autocmd. See  :h :autocmdG or any referenced neovim help-page from the fields of this data type.s#Pattern to match on. (default: "*")t Nested autocmd. (default: False)See :h autocmd-nestedu0Group in which the autocmd should be registered.vYou can use this type as the first argument for a function which is intended to be exported as a command. It holds information about the special attributes a command can take.x4i means that the function was not defined to handle a bang, otherwise it means that the bang was passed (5 6*) or that it was not passed when called (5 7).y&Range passed from neovim. Only set if 4 was used in the export declaration of the command.Example:  Just (1,12)z$Count passed by neovim. Only set if 4 was used in the export declaration of the command.{.Register that the command can/should/must use.|6Specification of a range that acommand can operate on.}6The line the cursor is at when the command is invoked.~2Let the command operate on every line of the file.8Let the command operate on each line in the given range.Newtype wrapper for a list of y. Any properly constructed object of this type is sorted and only contains zero or one object for each possible option.Options for commands.vSome command can also be described by using the OverloadedString extensions. This means that you can write a literal 8) inside your source file in place for a } value. See the documentation for each value on how these strings should look like (Both versions are compile time checked.)Stringliteral "sync" or "async"Register passed to the command.Stringliteral: "\"",Command takes a specific amount of argumentsuAutomatically set via template haskell functions. You really shouldn't use this option yourself unless you have to.'Determines how neovim passes the range.Stringliterals: "%" for ~9, "," for line and ",123" for 123 lines.ACommand handles a count. The argument defines the default count.-Stringliteral: string of numbers (e.g. "132")Command handles a bangStringliteral: "!"aThis option detemines how neovim should behave when calling some functionality on a remote host.Call the functionality entirely for its side effects and do not wait for it to finish. Calling a functionality with this flag set is completely asynchronous and nothing is really expected to happen. This is why a call like this is called notification on the neovim side of things.Call the function and wait for its result. This is only synchronous on the neovim side. This means that the GUI will (probably) not allow any user input until a reult is received.6Functionality specific functional description entries.All fields which are directly specified in these constructors are not optional, but can partialy be generated via the Template Haskell functions. The last field is a data type that contains all relevant options with sensible defaults, hence  can be used as an argument. Exported function. Callable via call name(arg1,arg2).:Name of the function (must start with an uppercase letter)FOption to indicate how neovim should behave when calling this functionExported Command. Callable via :Name arg1 arg2.9Name of the command (must start with an uppercase letter)>Options to configure neovim's behavior for calling the commandQExported autocommand. Will call the given function if the type and filter match.oNB: Since we are registering this on the Haskell side of things, the number of accepted arguments should be 0.)Type of the autocmd (e.g. "BufWritePost")Name for the function to callOptions for the autocmd (use + here if you don't want to change anything)Essentially just a string.Smart constructor for . This sorts the command options and removes duplicate entries for semantically the same thing. Note that the smallest option stays for whatever ordering is defined. It is best to simply not define the same thing multiple times.$opqrstuvwxyz{|~}%|}~vwxyz{qrstuop opqrstuvwxyz{|}~9+Classes used for Inter Plugin Communication(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone"#16CV A notification is similar to a . It essentially does the same thing, but the function is only called for its side effects. This type of message is sent by neovim if the caller there does not care about the result of the computation.Name of the function to call.Arguments for the function.A request is a data type containing the method to call, its arguments and an identifier used to map the result to the function that has been called.Name of the function to call.;Identifier to map the result to a function call invocation.Arguments for the function.CHaskell representation of supported Remote Procedure Call messages.,Method name, parameters, callback, timestamp'This class allows type safe casting of e to an actual message. The cast is successful if the type you're expecting matches the type in the  wrapper. This way, you can subscribe to an arbitrary message type withouth having to pattern match on the constructors. This also allows plugin authors to create their own message types without having to change the core code of nvim-hs.fTry to convert a given message to a value of the message type we are interested in. Will evaluate to 4 for any other type.wTaken from xmonad and based on ideas in /An Extensible Dynamically-Typed Hierarchy of Exceptions/, Simon Marlow, 2006.iUser-extensible messages must be put into a value of this type, so that it can be sent to other plugins. &''&/Communication between Haskell processes/threads(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone >Abstract description of the plugin provider's internal context(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone &'1;=>?KV]I:The state that the plugin provider wants to transition to.Quit the plugin provider.Restart the plugin provider.@The plugin provider failed to start or some other error occured.)The plugin provider started successfully.$This GADT is used to share information between stateless and stateful plugin threads since they work fundamentally in the same way. They both contain a function to register some functionality in the plugin provider as well as some values which are specific to the one or the other context.A wrapper for a reader value that contains extra fields required to communicate with the messagepack-rpc components and provide necessary data to provide other globally available operations.ZNote that you most probably do not want to change the fields prefixed with an underscore._A queue of messages that the event handler will propagate to appropriate threads and handlers.#The main thread will wait for this :Z to be filled with a value and then perform an action appropriate for the value of type .Since nvim-hs must have its Neovim.RPC.SocketReader and Neovim.RPC.EventHandler7 running to determine the actual channel id (i.e. the ;e value here) this field can only be set properly later. Hence, the value of this field is put in an <z. Name that is used to identify this provider. Assigning such a name is done in the neovim config (e.g. ~/.nvim/nvimrc).This =: is used to generate uniqe function names on the side of nvim-hsg. This is useful if you don't want to overwrite existing functions or if you create autocmd functions.^This map is used to dispatch received messagepack function calls to it's appropriate targets.In a registered functionality this field contains a function (and possibly some context dependent values) to register new functionality.UPlugin author supplyable custom configuration. Queried on the user-facing side with  or .A function map is a map containing the names of functions as keys and some context dependent value which contains all the necessary information to execute that function in the intended way.This type is only used internally and handles two distinct cases. One case is a direct function call, wich is simply a function that accepts a list of $ values and returns a result in the  ~ context. The second case is calling a function that has a persistent state. This is mediated to a thread that reads from a >{. (NB: persistent currently means, that state is stored for as long as the plugin provider is running and not restarted.).Type of the values stored in the function map.WThis data type is used to dispatch a remote function call to the appopriate recipient.4 functions are handled within a special thread, the >B is the communication endpoint for the arguments we have to pass. CThis is the environment in which all plugins are initially started.!Functions have to run in this transformer stack to communicate with neovim. If parts of your own functions dont need to communicate with neovim, it is good practice to factor them out. This allows you to write tests and spot errors easier. Essentially, you should treat this similar to ? in general haskell programs. Same as  for the InternalConfig. Same as  for the InternalConfig. Initialize a   context by supplying an InternalEnvironment.pCreate a new unique function name. To prevent possible name clashes, digits are stripped from the given suffix.1Create a new function map from the given list of  values.SConvenient helper to create a new config for the given state and read-only config. Sets the  field to 4. Create a new InternalConfigB object by providing the minimal amount of necessary information.-This function should only be called once per nvim-hs: session since the arguments are shared across processes.6User facing instance declaration for the reader state.      $        The Neovim context(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone]0@ specialized to a # value.!*Initiate a restart of the plugin provider."0Initiate the termination of the plugin provider.A %)*+,9  !" )*+, !" %9 KSplit module that can import Neovim.Context without creating import circles(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNoneCV#%- values are wraped inside this data type via -1 so that we can put plugins in an ordinary list.%@This data type contains meta information for the plugin manager.)VThis data type is used in the plugin registration to properly register the functions.+Extract the description of an ).,Extract the function of an ).-Wrap a %B in some nice blankets, so that we can put them in a simple list. #$%&'()*+,- )*,+#$%&'(-#$%&'()* Startup utilities for plugins(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone&/+This data type contains internal fields of nvim-hs= that may be useful for plugin authors. It is available via ask! inside the plugin startup code.1The configuration options for  Config.Dyre. This is always set if nvim-hs has been started via  Config.Dyre. Be sure to set up the 21 correctly if you issue a recompilation via the  Config.Dyre API.2)The GHC environment variables with which nvim-hs| has been started. This are mainly of significance if you want to use the same environment for compilation or a REPL that nvim-hs runs on.HThese variables have to be used if you want to invoke functionality of  Config.Dyre targeting nvim-hs./021/012/012 .The user editable and compilable configuration(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone3This data type contains information about the configuration of neovim. See the fields' documentation for what you possibly want to change. Also, the tutorial in the Neovim module should get you started.5The list of plugins. The IO type inside the list allows the plugin author to run some arbitrary startup code before creating a value of type #.6 Set the general logging options.73Internally used field. Changing this has no effect.Used by Dyre for storing compilation errors. 345673456734567-Data types and classes for the RPC components(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone"#16]%B8See  >https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md2 for details about the msgpack rpc specification.95Request in the sense of the msgpack rpc specificationzParameters * Message identifier that has to be put in the response to this request * Function name * Function arguments:5Response in the sense of the msgpack rpc specifcation;Parameters * Mesage identifier which matches a request * B an error  or a result ;:Notification in the sense of the msgpack rpc specification89;:89:;89:;"Common functons for the RPC module(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneQV]6 DJSimple data type defining the kind of socket the socket reader should use.ExUse the handle for receiving msgpack-rpc messages. This is suitable for an embedded neovim which is used in test cases.F?Read the connection information from the environment variable NVIM_LISTEN_ADDRESS.GUse a unix socket.HNUse an IP socket. First argument is the port and the second is the host name.I>Things shared between the socket reader and the event handler.KTA map from message identifiers (as per RPC spec) to a tuple with a timestamp and a <D that is used to communicate the result back to the calling thread.L8Message identifier for the next message as per RPC spec.MCreate a new basic configuration containing a communication channel for remote procedure call events and an empty lookup table for functions to mediate.N Create a C# from the given socket description.'The handle is not automatically closed.O\Close the handle and print a warning if the conduit chain has been interrupted prematurely. DHEFGIJLKMNO IJKLMDEFGHNODEFGHIJKLFunctions for calling functions(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone"#]O DSimply fail and call E in case an unexpected exception is thrown. This fails with a runtime exception. It is used by the Template Haskell API generator for functions that are defined as not being able to fail. If this exception occurs, it is a bug in neovim.FStrip the error result from the function call. This should only be used by the Template Haskell API generated code for functions that declare themselves as unfailable.P)Helper function that concurrently puts a # in the event queue and returns an G action that returns the result.QHelper function similar to PC that throws a runtime exception if the result is an error object.RZCall a neovim function synchronously. This function blocks until the result is available.S Similar to R, but throw a ) instead of returning it.THelper function similar to RC that throws a runtime exception if the result is an error object.ULifted variant of H.V&Wait for the result of the STM action.3This action possibly blocks as it is an alias for ' ioSTM -> ioSTM >>= liftIO . atomically.W Variant of V that discards the result.XWait for the result of the G action and call  . (loc++) . show" if the action returned an error.YX that discards the result.Z,Send the result back to the neovim instance.FFor better error messagesRParameters in an  array0result value of the call or the thrown exceptionXPrefix error message with this.Function call to neovim PQRSTUVWXYZ PQRTSUVWXYZEvent handling loop(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneK]T4I8Convenient monad transformer stack for the event handler[dThis function will establish a connection to the given socket and write msgpack-rpc requests to it.[[IJ&Template Haskell API generation module(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone]y K:Simply data type used to identify a string-ish type (e.g. 8, L, M for a value of type.a1Generate the API types and functions provided by nvim --api-info.The provided map allows the use of different Haskell types for the types defined in the API. The types must be an instance of 0z and they must form an isomorphism with the sent messages types. Currently, it provides a Convenient way to replace the String type with L, M or 8.b,Default type mappings for the requested API.NVThis function will create a wrapper function with neovim's function name as its name.Synchronous function: w buffer_get_number :: Buffer -> Neovim Int64 buffer_get_number buffer = scall "buffer_get_number" [toObject buffer] Asynchronous function: _ vim_eval :: String -> Neovim (TMVar Object) vim_eval str = acall "vim_eval" [toObject str] /Asynchronous function without a return value:  vim_feed_keys :: String -> String -> Bool -> Neovim () vim_feed_keys keys mode escape_csi = acallVoid "vim_feed_keys" [ toObject keys , toObject mode , toObject escape_csi ] O5 createDataTypeWithObjectComponent SomeName [Foo,Bar] will create this: i data SomeName = Foo !Object | Bar !Object deriving (Typeable, Eq, Show) PIf the first parameter is mkName NeovimException , this function will generate "instance Exception NeovimException.Q+customTypeInstance Foo [(Bar, 1), (Quz, 2)] will create this: - instance Serializable Foo where toObject (Bar bs) = ObjectExt 1 bs toObject (Quz bs) = ObjectExt 2 bs fromObject (ObjectExt 1 bs) = return $ Bar bs fromObject (ObjectExt 2 bs) = return $ Quz bs fromObject o = Left $ "Object is not convertible to: Foo Received: " <> show o chDefine an exported function by providing a custom name and referencing the function you want to export.8Note that the name must start with an upper case letter. Example: 5 $(function "MyExportedFunction" 'myDefinedFunction) Sync d>Define an exported function. This function works exactly like cb, but it generates the exported name automatically by converting the first letter to upper case.RGiven a value of type SF, test whether it can be classified according to the constructors of ArgType.e Similarly to c@, this function is used to export a command with a custom name.8Note that commands must start with an upper case letter.Due to limitations on the side of (neo)vim, commands can only have one of the following five signatures, where you can replace 8 with M or L if you wish:v ->   r st ()v -> T 8 ->   r st ()v -> 8 ->   r st ()v -> [8] ->   r st ()v -> 8 -> [8] ->   r st () Example: . $(command "RememberThePrime" 'someFunction) [] Note that the list of command options (i.e. the last argument) removes duplicate options by means of some internally convenient sorting. You should simply not define the same option twice.f=Define an exported command. This function works exactly like eR, but it generates the command name by converting the first letter to upper case.UGenerate a function of type [Object] -> Neovim' Object from the argument function.The function ' add :: Int -> Int -> Int add = (+)  will be converted to 3 args -> case args of [x,y] -> case pure add  * fromObject x  *u fromObject y of Left e -> err $ "Wrong type of arguments for add: " ++ e Right action -> toObject  $J action _ -> err $ "Wrong number of arguments for add: " ++ show xs }VWX     YZ[\]^_`a  #"!%bcdefghijklmnopqrstuvwxyz{|}~0132456789abcdefgacdefgbKString based API(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone16QVDolmnopqrtsuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~xrstpqnolm~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      ~}|{zyxwvulmnopqrst*API for interacting with the quickfix list(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone"#6] CAdd items to the current list (or create a new one if none exists).:Replace current list (or create a new one if none exists).Create a new list.Simple error type enum.KQuickfix list item. The parameter names should mostly conform to those in :h setqflist()o. Some fields are merged to explicitly state mutually exclusive elements or some other behavior of the fields.see < for creating a value of this type without typing too much.YSince the filename is only used if no buffer can be specified, this field is a merge of bufnr and filename.2Line number or search pattern to locate the error.\A tuple of a column number and a boolean indicating which kind of indexing should be used. 6/ means that the visual column should be used. 7 means to use the byte index. Error number.Description of the error.Type of error."This is a wrapper around neovim's  setqflist(). strType2 can be any string that you can append to (hence ) that is also an instance of 0!. You can e.g. use the plain old 8. Create a 6 by providing the minimal amount of arguments needed.buffer of file nameline number or pattern      *Plugin and functionality registration code(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone "#&'V]]Callthe vimL functions to define a function, command or autocmd on the neovim side. Returns 6 if registration was successful.7Note that this does not have any effect on the side of nvim-hs.eReturn or retrive the provider name that the current instance is associated with on the neovim side.+Register an autocmd in the current context. This means that, if you are currently in a stateful plugin, the function will be called in the current thread and has access to the configuration and state of this thread. .6Note that the function you pass must be fully applied.8Create a listening thread for events and add update the  with the corresponding > s (i.e. communication channels).+,The event to register to (e.g. BufWritePost)"Fully applied function to registerA  if the registration worked#%&'(-()*+)(-#%&'(+*?The component which reads RPC messages from the neovim instance(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone"#K]u,cThis function will establish a connection to the given socket and read msgpack-rpc events from it.;Sink that delegates the messages depending on their type. >https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.mdAct upon the received request or notification. The main difference between the two is that a notification does not generate a reply. The distinction between those two cases is done via the first paramater which is T the function call identifier.,-,-Utility functions(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone].Execute the given action with a changed set of environment variables and restore the original state of the environment afterwards./ with a monadic predicate.0 with a monadic predicate../01./01CInternals for a config helper plugin that helps recompiling nvim-hs(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone"#]ޅ7!Simple function that will return Pong$ if the plugin provider is running.8IRecompile the plugin provider and put comile errors in the quickfix list.9Note that restarting the plugin provider implies compilation because Dyre does this automatically. However, if the recompilation fails, the previously compiled binary is executed. This essentially means that restarting may take more time then you might expect.=If you provide a bang to the command, the cache directory of nvim-hs is forcibly removed.A:Skip anything until the next location information appears.?The result will be a triple of filename, line number and column"Try to parse location information. /some/path/to/a/file.hs:42:88:23654789:;<=>?@AB72345689:;<=>?@AB234564Helper plugin to ease recompiling the nvim-hs config(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone]QCC$Wrapper for the actual main function(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone]DA D function receives the Ys of all running threads which have been started by the plugin provider as well as the  with the custom field set to I. These information can be used to properly clean up a session and then do something else. The transition handler is first called after the plugin provider has started.O*This is essentially the main function for nvim-hs, at least if you want to use  Config.Dyre for the configuration.PQThis main functions can be used to create a custom executable without using the  Config.Dyre library while still using the nvim-hs$ specific configuration facilities.QIGeneric main function. Most arguments are optional or have sane defaults.RWIf the plugin provider is started with dyre, this handler is used to handle a restart.QSee nvim-hs executables --help function or MDEFKJHGILMNOPQRLEFGHIJKSMNODPQREFGHIJK#API for the neovim plugin provider nvim-hs(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHC (due to Template Haskell)NonedT"Default configuration options for nvim-hsY. If you want to keep the default plugins enabled, you can define your config like this: main = O TD { plugins = myPlugins ++ plugins defaultConfig }      _`a   #"!$%)*+,013245678qrstuvwxyz{|~}  #$%&'(-/01234567VWXYcdefglmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~+./0OTg O34567T/012#$%&'(0123465 -cdefg|}~vwxyz{qrstu+VWXY )*+./078 %#""!$, Testing functions(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone] _UType synonym for  .WRun the given  y action according to the given parameters. The embedded neovim instance is started without a config (i.e. it is passed -u NONE).If you want to run your tests purely from haskell, you have to setup the desired state of neovim with the help of the functions in Neovim.API.String.W-Optional path to a file that should be opened7Maximum time (in seconds) that a test is allowed to runRead-only configuration Test caseUVWWUVUV3Utilities to debug Neovim and nvim-hs functionality(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone]XRun a   function.MThis function connects to the socket pointed to by the environment variable $NVIM_LISTEN_ADDRESS and executes the command. It does not register itself as a real plugin provider, you can simply call neovim-functions from the module Neovim.API.String this way.^Tip: If you run a terminal inside a neovim instance, then this variable is automatically set.YRun a Neovim' function. debug' a = fmap fst  $ debug () () a See documentation for X.ZzThis function is intended to be run _once_ in a ghci session that to give a REPL based workflow when developing a plugin.6Note that the dyre-based reload mechanisms, i.e. the Neovim.Plugin.ConfigHelper! plugin, is not started this way.To use this in ghci, you simply bind the results to some variables. After each reload of ghci, you have to rebind those variables.Example:   (tids, cfg) <- Z 4  ]( cfg $ vim_call_function "getqflist" []  ( ( []))  :r   (tids, cfg) <- Z 4 [*Quit a previously started plugin provider.\(Restart the development plugin provider.](Convenience function to run a stateless   function.^-Print the global function map to the console.#     _`a   #"!$%)*+,013245678qrstuvwxyz{|~}  #$%&'(-/01234567VWXYcdefglmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~+./0OTXYZ[\]^XYZ[\^] !"#$%&'(&')&'*&'+&',&'-&'.&'/&'012312412512612712812912:12;12<12=12>?@A?@B?@C?@D?EF?EG?HIJKLJKMJKNJKOJKPQRSQRTUVWUXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                        ! " # $ % % & ' ( ) * + , - . / 0   1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C DEFGH I I J J K L M N O P Q R S S T U V % W X Y Z[\]^_`abcdefghhijklmnopqrstuvwxyz{|}~[      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ASBCDEFGHIJKKLMNOPQRSTUVWXYZ[\]^(_`abcdefghijkllmnopqrstuvwxwyz{|z{}z{~z{zzzzzzzzzzzzzzzzz      !"#$%w&'(')'*'+,-./0/1/2/3#$4#$5#$6#$7#$8#$9#$:#$;#$<#$=#$>#$?@A&BC&BD&BE&BF&BG&BH&BI&BJ&BK&BL&BM&BN&BO&BP&BQ&BR&BS&BT&BU&BV&BW&BX&BY&BZw[w\,-],-^w_ `a,-bcdefgchi,-jkl!mnopqrstufvfwxxyz{|}~wwkkkkkkwwfwwwwwwwwwwuuuuuuuuuw w w w wwn &nvim-hs-1.0.0.2-6pcqhYlrbRL29izsxlQCpXNeovim.ClassesNeovimNeovim.ContextNeovim.Plugin.IPC.ClassesNeovim.Compat.MegaparsecNeovim.ExceptionsNeovim.API.Parser Neovim.LogNeovim.Plugin.ClassesNeovim.Context.InternalNeovim.Plugin.InternalNeovim.Plugin.Startup Neovim.ConfigNeovim.RPC.ClassesNeovim.RPC.CommonNeovim.RPC.FunctionCallNeovim.RPC.EventHandler Neovim.API.THNeovim.API.StringNeovim.Quickfix Neovim.PluginNeovim.RPC.SocketReader Neovim.Util#Neovim.Plugin.ConfigHelper.InternalNeovim.Plugin.ConfigHelper Neovim.Main Neovim.Test Neovim.DebugNeovim.Plugin.IPCbase GHC.GenericsGenericControl.Monad.IO.ClassliftIO1data-default-class-0.1.2.0-65ekPiG1XHJGG1Sy8NeI1LData.Default.Classdef&hslogger-1.2.10-3DRKHaz9lDQDwxyPgsWkM2 System.Log EMERGENCYALERTCRITICALERRORWARNINGNOTICEINFODEBUGPriority'messagepack-0.5.4-11N1Zr37UKee7trZRD8L1Data.MessagePack ObjectExt ObjectMap ObjectArray ObjectBinary ObjectString ObjectDouble ObjectFloat ObjectBool ObjectInt ObjectUInt ObjectNilObject mtl-2.2.1-DscMMmDQUE6GBfOSl4qMUHControl.Monad.State.ClassgetsmodifyputgetControl.Monad.Reader.ClassasksaskControl.Monad.Error.Class throwError*prettyprinter-1.2.1-1zha0w8F0sW2Cmd9Q3a4bf"Data.Text.Prettyprint.Doc.Internal<+>Doc prettyListprettyPretty:prettyprinter-ansi-terminal-1.1.1.2-1zTvxiPruAd68cxmRge6wU2Data.Text.Prettyprint.Doc.Render.Terminal.InternalputDoc AnsiStyle time-1.8.0.2Data.Time.Clock.POSIXgetCurrentTime Data.Time.Clock.Internal.UTCTimeUTCTimeParserNeovimException ErrorMessage ErrorResultexceptionToDoc$fIsStringNeovimException$fExceptionNeovimException$fShowNeovimException NvimObjecttoObjectfromObjectUnsafe fromObject fromObject' Dictionary+: docToObject docFromObject docToText$fNvimObject(,,,,,,,,)$fNvimObject(,,,,,,,)$fNvimObject(,,,,,,)$fNvimObject(,,,,,)$fNvimObject(,,,,)$fNvimObject(,,,)$fNvimObject(,,)$fNvimObject(,)$fNvimObjectObject$fNvimObjectByteString$fNvimObjectText$fNvimObjectMap$fNvimObjectEither$fNvimObjectMaybe$fNvimObject[]$fNvimObject[]0$fNvimObjectInt$fNvimObjectWord8$fNvimObjectWord16$fNvimObjectWord32$fNvimObjectWord64$fNvimObjectWord$fNvimObjectInt8$fNvimObjectInt16$fNvimObjectInt32$fNvimObjectInt64$fNvimObjectInteger$fNvimObjectDouble$fNvimObjectBool$fNvimObject() NeovimAPI errorTypes customTypes functionsNeovimFunctionname parameterscanFailasync returnType NeovimType SimpleType NestedTypeVoidparseAPI$fShowNeovimType$fEqNeovimType$fShowNeovimFunction$fShowNeovimAPI disableLogger withLoggerHasFunctionNameAutocmdOptions acmdPattern acmdNested acmdGroupCommandArgumentsbangrangecountregisterRangeSpecification CurrentLine WholeFile RangeCountCommandOptionsgetCommandOptions CommandOptionCmdSync CmdRegisterCmdNargsCmdRangeCmdCountCmdBang SynchronousAsyncSyncFunctionalityDescriptionFunctionCommandAutocmd FunctionNameFmkCommandOptions$fPrettyFunctionName$fNFDataFunctionName$fNvimObjectSynchronous$fIsStringSynchronous$fPrettySynchronous$fNFDataSynchronous$fNvimObjectRangeSpecification$fPrettyRangeSpecification$fNFDataRangeSpecification$fIsStringCommandOption$fPrettyCommandOption$fNFDataCommandOption$fNvimObjectCommandOptions$fPrettyCommandOptions$fNFDataCommandOptions$fNvimObjectCommandArguments$fDefaultCommandArguments$fPrettyCommandArguments$fNFDataCommandArguments$fNvimObjectAutocmdOptions$fDefaultAutocmdOptions$fPrettyAutocmdOptions$fNFDataAutocmdOptions $fPrettyFunctionalityDescription $fNFDataFunctionalityDescription)$fHasFunctionNameFunctionalityDescription$fEqFunctionName$fOrdFunctionName$fShowFunctionName$fReadFunctionName$fGenericFunctionName$fShowSynchronous$fReadSynchronous$fEqSynchronous$fOrdSynchronous$fEnumSynchronous$fGenericSynchronous$fEqRangeSpecification$fOrdRangeSpecification$fShowRangeSpecification$fReadRangeSpecification$fGenericRangeSpecification$fEqCommandOption$fOrdCommandOption$fShowCommandOption$fReadCommandOption$fGenericCommandOption$fEqCommandOptions$fOrdCommandOptions$fShowCommandOptions$fReadCommandOptions$fGenericCommandOptions$fEqCommandArguments$fOrdCommandArguments$fShowCommandArguments$fReadCommandArguments$fGenericCommandArguments$fShowAutocmdOptions$fReadAutocmdOptions$fEqAutocmdOptions$fOrdAutocmdOptions$fGenericAutocmdOptions$fShowFunctionalityDescription$fReadFunctionalityDescription$fEqFunctionalityDescription$fOrdFunctionalityDescription!$fGenericFunctionalityDescription Notification notMethodnotArgsRequest reqMethodreqIdreqArgs FunctionCallMessage fromMessage SomeMessage$fPrettyFunctionCall$fMessageFunctionCall$fPrettyRequest$fMessageRequest$fNFDataRequest$fPrettyNotification$fMessageNotification$fNFDataNotification $fEqRequest $fOrdRequest $fShowRequest$fGenericRequest$fEqNotification$fOrdNotification$fShowNotification$fGenericNotificationStateTransitionQuitRestartFailure InitSuccessPluginSettingsStatefulSettingsConfig eventQueue transitionTo providerName uniqueCounterglobalFunctionMappluginSettings customConfig FunctionMapFunctionMapEntry FunctionTypeStatefulunNeovimask'asks'exceptionHandlers runNeovimrunNeovimInternalnewUniqueFunctionName mkFunctionMap retypeConfig newConfig$fPrettyFunctionType$fMonadUnliftIONeovim$fMonadResourceNeovim$fMonadReaderenvNeovim$fShowStateTransition$fFunctorNeovim$fApplicativeNeovim $fMonadNeovim$fMonadIONeovim$fMonadThrowNeovimerrerrOnInvalidResultrestartquit NeovimPluginPlugin environmentexportsExportedFunctionalityEFgetDescription getFunction wrapPlugin&$fHasFunctionNameExportedFunctionality StartupConfig dyreParamsghcEnvironmentVariables NeovimConfigplugins logOptions errorMessageResponse$fPrettyMessage$fNvimObjectMessage$fMessageMessage$fNFDataMessage $fEqMessage $fOrdMessage $fShowMessage$fGenericMessage SocketTypeStdout Environment UnixSocketTCP RPCConfig recipients nextMessageId newRPCConfig createHandle cleanUpHandleacallacall'scall scallThrowscall' atomically'waitwait'waitErrwaitErr'respondrunEventHandler$fFunctorEventHandler$fApplicativeEventHandler$fMonadEventHandler$fMonadIOEventHandler$fMonadReaderEventHandler generateAPIdefaultAPITypeToHaskellTypeMapfunction function'commandcommand'autocmd $fEqArgType $fOrdArgType $fShowArgType $fReadArgTypeWindowTabpageBufferNeovimExceptionGenNeovimValidationnvim_buf_line_countnvim_buf_line_count'buffer_get_linebuffer_get_line'nvim_buf_attachnvim_buf_attach'nvim_buf_detachnvim_buf_detach'buffer_set_linebuffer_set_line'buffer_del_linebuffer_del_line'buffer_get_line_slicebuffer_get_line_slice'nvim_buf_get_linesnvim_buf_get_lines'buffer_set_line_slicebuffer_set_line_slice'nvim_buf_set_linesnvim_buf_set_lines'nvim_buf_get_varnvim_buf_get_var'nvim_buf_get_changedticknvim_buf_get_changedtick'nvim_buf_get_keymapnvim_buf_get_keymap'nvim_buf_get_commandsnvim_buf_get_commands'nvim_buf_set_varnvim_buf_set_var'nvim_buf_del_varnvim_buf_del_var'buffer_set_varbuffer_set_var'buffer_del_varbuffer_del_var'nvim_buf_get_optionnvim_buf_get_option'nvim_buf_set_optionnvim_buf_set_option'nvim_buf_get_numbernvim_buf_get_number'nvim_buf_get_namenvim_buf_get_name'nvim_buf_set_namenvim_buf_set_name'nvim_buf_is_validnvim_buf_is_valid' buffer_insertbuffer_insert'nvim_buf_get_marknvim_buf_get_mark'nvim_buf_add_highlightnvim_buf_add_highlight'nvim_buf_clear_highlightnvim_buf_clear_highlight'nvim_tabpage_list_winsnvim_tabpage_list_wins'nvim_tabpage_get_varnvim_tabpage_get_var'nvim_tabpage_set_varnvim_tabpage_set_var'nvim_tabpage_del_varnvim_tabpage_del_var'tabpage_set_vartabpage_set_var'tabpage_del_vartabpage_del_var'nvim_tabpage_get_winnvim_tabpage_get_win'nvim_tabpage_get_numbernvim_tabpage_get_number'nvim_tabpage_is_validnvim_tabpage_is_valid'nvim_ui_attachnvim_ui_attach' ui_attach ui_attach'nvim_ui_detachnvim_ui_detach'nvim_ui_try_resizenvim_ui_try_resize'nvim_ui_set_optionnvim_ui_set_option' nvim_command nvim_command'nvim_get_hl_by_namenvim_get_hl_by_name'nvim_get_hl_by_idnvim_get_hl_by_id' nvim_feedkeysnvim_feedkeys' nvim_input nvim_input'nvim_replace_termcodesnvim_replace_termcodes'nvim_command_outputnvim_command_output' nvim_eval nvim_eval'nvim_execute_luanvim_execute_lua'nvim_call_functionnvim_call_function'nvim_call_dict_functionnvim_call_dict_function' nvim_strwidthnvim_strwidth'nvim_list_runtime_pathsnvim_list_runtime_paths'nvim_set_current_dirnvim_set_current_dir'nvim_get_current_linenvim_get_current_line'nvim_set_current_linenvim_set_current_line'nvim_del_current_linenvim_del_current_line' nvim_get_var nvim_get_var' nvim_set_var nvim_set_var' nvim_del_var nvim_del_var' vim_set_var vim_set_var' vim_del_var vim_del_var' nvim_get_vvarnvim_get_vvar'nvim_get_optionnvim_get_option'nvim_set_optionnvim_set_option'nvim_out_writenvim_out_write'nvim_err_writenvim_err_write'nvim_err_writelnnvim_err_writeln'nvim_list_bufsnvim_list_bufs'nvim_get_current_bufnvim_get_current_buf'nvim_set_current_bufnvim_set_current_buf'nvim_list_winsnvim_list_wins'nvim_get_current_winnvim_get_current_win'nvim_set_current_winnvim_set_current_win'nvim_list_tabpagesnvim_list_tabpages'nvim_get_current_tabpagenvim_get_current_tabpage'nvim_set_current_tabpagenvim_set_current_tabpage'nvim_subscribenvim_subscribe'nvim_unsubscribenvim_unsubscribe'nvim_get_color_by_namenvim_get_color_by_name'nvim_get_color_mapnvim_get_color_map' nvim_get_modenvim_get_mode'nvim_get_keymapnvim_get_keymap'nvim_get_commandsnvim_get_commands'nvim_get_api_infonvim_get_api_info'nvim_set_client_infonvim_set_client_info'nvim_get_chan_infonvim_get_chan_info'nvim_list_chansnvim_list_chans'nvim_call_atomicnvim_call_atomic'nvim_parse_expressionnvim_parse_expression' nvim_list_uisnvim_list_uis'nvim_get_proc_childrennvim_get_proc_children' nvim_get_procnvim_get_proc'nvim_win_get_bufnvim_win_get_buf'nvim_win_get_cursornvim_win_get_cursor'nvim_win_set_cursornvim_win_set_cursor'nvim_win_get_heightnvim_win_get_height'nvim_win_set_heightnvim_win_set_height'nvim_win_get_widthnvim_win_get_width'nvim_win_set_widthnvim_win_set_width'nvim_win_get_varnvim_win_get_var'nvim_win_set_varnvim_win_set_var'nvim_win_del_varnvim_win_del_var'window_set_varwindow_set_var'window_del_varwindow_del_var'nvim_win_get_optionnvim_win_get_option'nvim_win_set_optionnvim_win_set_option'nvim_win_get_positionnvim_win_get_position'nvim_win_get_tabpagenvim_win_get_tabpage'nvim_win_get_numbernvim_win_get_number'nvim_win_is_validnvim_win_is_valid'buffer_line_countbuffer_line_count'buffer_get_linesbuffer_get_lines'buffer_set_linesbuffer_set_lines'buffer_get_varbuffer_get_var'buffer_get_optionbuffer_get_option'buffer_set_optionbuffer_set_option'buffer_get_numberbuffer_get_number'buffer_get_namebuffer_get_name'buffer_set_namebuffer_set_name'buffer_is_validbuffer_is_valid'buffer_get_markbuffer_get_mark'buffer_add_highlightbuffer_add_highlight'buffer_clear_highlightbuffer_clear_highlight'tabpage_get_windowstabpage_get_windows'tabpage_get_vartabpage_get_var'tabpage_get_windowtabpage_get_window'tabpage_is_validtabpage_is_valid' ui_detach ui_detach' ui_try_resizeui_try_resize' vim_command vim_command' vim_feedkeys vim_feedkeys' vim_input vim_input'vim_replace_termcodesvim_replace_termcodes'vim_command_outputvim_command_output'vim_eval vim_eval'vim_call_functionvim_call_function' vim_strwidth vim_strwidth'vim_list_runtime_pathsvim_list_runtime_paths'vim_change_directoryvim_change_directory'vim_get_current_linevim_get_current_line'vim_set_current_linevim_set_current_line'vim_del_current_linevim_del_current_line' vim_get_var vim_get_var' vim_get_vvar vim_get_vvar'vim_get_optionvim_get_option'vim_set_optionvim_set_option' vim_out_writevim_out_write' vim_err_writevim_err_write'vim_report_errorvim_report_error'vim_get_buffersvim_get_buffers'vim_get_current_buffervim_get_current_buffer'vim_set_current_buffervim_set_current_buffer'vim_get_windowsvim_get_windows'vim_get_current_windowvim_get_current_window'vim_set_current_windowvim_set_current_window'vim_get_tabpagesvim_get_tabpages'vim_get_current_tabpagevim_get_current_tabpage'vim_set_current_tabpagevim_set_current_tabpage' vim_subscribevim_subscribe'vim_unsubscribevim_unsubscribe'vim_name_to_colorvim_name_to_color'vim_get_color_mapvim_get_color_map'vim_get_api_infovim_get_api_info'window_get_bufferwindow_get_buffer'window_get_cursorwindow_get_cursor'window_set_cursorwindow_set_cursor'window_get_heightwindow_get_height'window_set_heightwindow_set_height'window_get_widthwindow_get_width'window_set_widthwindow_set_width'window_get_varwindow_get_var'window_get_optionwindow_get_option'window_set_optionwindow_set_option'window_get_positionwindow_get_position'window_get_tabpagewindow_get_tabpage'window_is_validwindow_is_valid'$fNvimObjectNeovimExceptionGen$fExceptionNeovimExceptionGen$fNFDataNeovimExceptionGen$fNvimObjectBuffer$fNFDataBuffer$fNvimObjectTabpage$fNFDataTabpage$fNvimObjectWindow$fNFDataWindow$fEqNeovimExceptionGen$fShowNeovimExceptionGen$fGenericNeovimExceptionGen $fEqBuffer $fShowBuffer$fGenericBuffer $fEqTabpage $fShowTabpage$fGenericTabpage $fEqWindow $fShowWindow$fGenericWindowQuickfixActionAppendReplaceNewQuickfixErrorTypeWarningErrorQuickfixListItemQFItem bufOrFile lnumOrPatterncolnrtext errorType SignLocation LineNumber SearchPattern ColumnNumber VisualColumnByteIndexColumnNoColumn setqflistquickfixListItem$fNFDataColumnNumber$fNFDataSignLocation$fNvimObjectQuickfixErrorType$fNFDataQuickfixErrorType$fNvimObjectQuickfixListItem$fNFDataQuickfixListItem$fNvimObjectQuickfixAction$fNFDataQuickfixAction$fEqColumnNumber$fOrdColumnNumber$fShowColumnNumber$fGenericColumnNumber$fEqSignLocation$fOrdSignLocation$fShowSignLocation$fGenericSignLocation$fEqQuickfixErrorType$fOrdQuickfixErrorType$fShowQuickfixErrorType$fReadQuickfixErrorType$fEnumQuickfixErrorType$fBoundedQuickfixErrorType$fGenericQuickfixErrorType$fEqQuickfixListItem$fShowQuickfixListItem$fGenericQuickfixListItem$fEqQuickfixAction$fOrdQuickfixAction$fEnumQuickfixAction$fBoundedQuickfixAction$fShowQuickfixAction$fGenericQuickfixActionstartPluginThreadsregisterPlugin addAutocmdrunSocketReader parseParamswithCustomEnvironmentwhenMunlessMoneLineErrorMessageConfigHelperEnvdyreParametersenvironmentVariables quickfixList pingNvimhsrecompileNvimhs restartNvimhsparseQuickfixItemspQuickfixListItem pSeveritypShortDesrciptionpLongDescription tabOrSpace blankLine pLocationpIntpluginTransitionHandlerCommandLineOptionsOpthostPortunixenvVarlogOptslogger optParseroptsneovimrealMainrunPluginProvider finishDyre$fDefaultCommandLineOptions defaultConfigSecondstestWithEmbeddedNeovimdebugdebug' develMain quitDevelMainrestartDevelMain runNeovim'printGlobalFunctionMapControl.ApplicativeoptionalGHC.Baseempty<|>/parser-combinators-1.0.0-E8zZX4pvNRLEYcUFPBPgL4Control.Applicative.CombinatorsbetweenchoiceeitherPoptionControl.Monad.Combinatorscount'endByendBy1manymanyTillsomesomeTillsepBysepBy1sepEndBy sepEndBy1skipManyskipSome skipCount skipManyTill skipSomeTill'megaparsec-6.5.0-8CoyINGGrFy8vOqDgGgj6eText.Megaparsec.Charstring'stringsatisfynoneOfoneOfnotCharanyCharchar'char categoryName charCategory latin1Char asciiChar separatorChar symbolCharpunctuationChar numberCharmarkChar hexDigitChar octDigitChar digitChar printChar alphaNumChar letterChar lowerChar upperChar spaceChar controlCharspace1spacetabeolcrlfnewlineText.MegaparsecdbgsetParserState setTabWidth getTabWidthsetTokensProcessedgetTokensProcessed popPosition pushPosition setPositiongetNextTokenPosition getPositionsetInputgetInputatEndtakeRestregionmatch customFailure unexpected runParserT' runParserT runParser' runParser parseTest' parseTest parseMaybeparseParsecText.Megaparsec.InternalParsecTText.Megaparsec.Class MonadParsectryeof lookAheadlabelfailure fancyFailurehidden notFollowedBy withRecovery observingtokentokens takeWhileP takeWhile1PtakePgetParserStateupdateParserStateText.Megaparsec.ErrorparseErrorTextPrettysourcePosStackPrettyparseErrorPretty_parseErrorPretty'parseErrorPrettyerrorPos ErrorItemTokensLabel EndOfInput ErrorFancy ErrorFailErrorIndentation ErrorCustom ParseError TrivialError FancyError ShowToken showTokens LineToken tokenAsChartokenIsNewlineShowErrorComponentshowErrorComponentText.Megaparsec.StreamStreamToken tokenToChunk tokensToChunk chunkToTokens chunkLength chunkEmpty positionAt1 positionAtNadvance1advanceNtake1_takeN_ takeWhile_Text.Megaparsec.StateState stateInputstatePosstateTokensProcessed stateTabWidthText.Megaparsec.PossourcePosPretty initialPosdefaultTabWidthpos1unPosmkPosPosInvalidPosException SourcePos sourceLine sourceColumn sourceNamedeepseq-1.4.3.0Control.DeepSeqNFDataidGHC.IntInt8Int16Int32Int64ghc-prim GHC.TypesWordGHC.WordWord8Word16Word32Word64rnf2rnf1rwhnf<$!!>force$!!deepseqrnfNFData1liftRnfNFData2liftRnf2 System.IOputStrLnSystem.Log.Logger traploggingremoveAllHandlersupdateGlobalLoggersaveGlobalLogger clearLevelsetLevelgetLevel setHandlers removeHandler addHandlerlogL getRootLogger getLogger emergencyMalertM criticalMerrorMwarningMnoticeMinfoMdebugMlogMrootLoggerNameLoggerNothingJustTrueFalseStringGHC.MVarMVarInt"stm-2.4.4.1-6AExGOUG8NB2Rzejnay0wwControl.Concurrent.STM.TMVarTMVar GHC.Conc.SyncTVarControl.Concurrent.STM.TQueueTQueueIO GHC.ExceptionthrowMonadIO Data.EitherEitherGHC.IO.Handle.TypesHandleunexpectedExceptionGHC.ErrerrorwithIgnoredExceptionSTM atomically EventHandlerArgType#text-1.2.2.2-EakMpasry3jA6OIwSZhq9MData.Text.InternalTextbytestring-0.10.8.2Data.ByteString.Internal ByteStringcreateFunction%createDataTypeWithByteStringComponentexceptionInstancecustomTypeInstanceclassifyArgTypetemplate-haskellLanguage.Haskell.TH.SyntaxTypeMaybefunctionImplementationassert Data.DataDataData.Typeable.InternalTypeableGHC.IO.ExceptionSomeAsyncException IOException Exception toException fromExceptiondisplayException SomeException'unliftio-0.2.7.0-576EP1oBkP8F53AhG1QPVDUnliftIO.Exception fromEitherM fromEitherIO fromEither impureThrowthrowTostringException throwStringuninterruptibleMask_mask_uninterruptibleMaskmaskisAsyncExceptionisSyncExceptiontoAsyncExceptiontoSyncExceptionthrowIO onException withExceptionfinallybracketOnError_bracketOnErrorbracket_bracket evaluateDeepevaluate catchesDeepcatches pureTryDeeppureTrytryJust tryAnyDeeptryDeeptryAnytryIO handleJust handleAnyDeep handleDeep handleAnyhandleIOhandle catchJust catchAnyDeep catchDeepcatchAnycatchIOcatchHandlerSyncExceptionWrapperAsyncExceptionWrapperStringException StringyTypeListOfStringyTypesOptionalCommandArgumentsType OtherTypeMonoidregisterWithNeovimgetProviderNameregisterStatefulFunctionality&resourcet-1.2.1-4MSJGkavGi6724iYk6uRzq%Control.Monad.Trans.Resource.Internal ReleaseKeymessageHandlerSinkhandleRequestOrNotificationwhen Control.MonadunlessThreadId<$ Applicativepure<*>*>liftA2<*memptymappendmconcat Data.Monoid<> WrappedMonad WrapMonad unwrapMonad WrappedArrow WrapArrow unwrapArrowZipList getZipListData.Functor.ConstConstgetConstDualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductFirstgetFirstLastgetLastAltgetAlt Data.Functorvoid<$>liftA3liftA<**> AlternativeRight