0X ;      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789: Logging utilities and reexports GHC experimentalwoozletoff@gmail.comNone Disable logging to stderr. GInitialize the root logger to avoid stderr and set it to log the given F file instead. Simply wrap the main entry point with this function to  initialze the logger.   main =   /home/dude/nvim.log Debug $ do  ;  Hello, World!  #< =>?@ABCDEFGHIJKLMNOPQRS   Startup utilities for plugins GHC experimentalwoozletoff@gmail.comNone +This data type contains internal fields of nvim-hs that may 3 be useful for plugin authors. It is available via ask inside  the plugin startup code. The configuration options for  Config.Dyre. This is always set if  nvim-hs has been started via  Config.Dyre. Be sure to set up the  , correctly if you issue a recompilation via  the  Config.Dyre API. )The GHC environment variables with which nvim-hs has been started. I This are mainly of significance if you want to use the same environment  for compilation or a REPL that nvim-hs runs on. GThese variables have to be used if you want to invoke functionality of   Config.Dyre targeting nvim-hs.      >Type classes used for conversion of msgpack and Haskell types  experimentalwoozletoff@gmail.comNone Conversion from . files to Haskell types and back with respect  to neovim's interpretation. $JA generic vim dictionary is a simply a map from strings to objects. This G type alias is sometimes useful as a type annotation especially if the ) OverloadedStrings extension is enabled. %(Convenient operator to create a list of  from normal values. T$Right-biased instance for toObject. & !"#$%UVWXYZ[\]^_`aTbcdefghijklmnopqrstuvwxyz{| !"#$% !"#$%# !"#$%UVWXYZ[\]^_`aTbcdefghijklmnopqrs*Classes and data types related to plugins GHC experimentalwoozletoff@gmail.comNone&6Conveniennce class to extract a name from some value. (5Options that can be used to register an autocmd. See  :h :autocmd or any @ referenced neovim help-page from the fields of this data type. *Pattern to match on. (default: "*") +!Nested autocmd. (default: False) See :h autocmd-nested ,1Group in which the autocmd should be registered. -DYou can use this type as the first argument for a function which is N intended to be exported as a command. It holds information about the special  attributes a command can take. /}; means that the function was not defined to handle a bang, . otherwise it means that the bang was passed (~  ) or that it  was not passed when called (~ ). 0&Range passed from neovim. Only set if < was used in the export  declaration of the command.  Example:   Just (1,12)1$Count passed by neovim. Only set if ; was used in the export  declaration of the command. 2Register that the command can/should/ must use. 37Specification of a range that acommand can operate on. 49Let the command operate on each line in the given range. 53Let the command operate on every line of the file. 67The line the cursor is at when the command is invoked. 7Newtype wrapper for a list of 9. Any properly constructed M object of this type is sorted and only contains zero or one object for each  possible option. 9Options for commands. MSome command can also be described by using the OverloadedString extensions. ) This means that you can write a literal  inside your source file in  place for a 90 value. See the documentation for each value on N how these strings should look like (Both versions are compile time checked.) :Command handles a bang Stringliteral: "!" ;2Command handles a count. The argument defines the  default count. 'Stringliteral: string of numbers (e.g. 132) <(Determines how neovim passes the range. Stringliterals: "%" for 5, "," for line  and ",123" for 123 lines. =-Command takes a specific amount of arguments 6Automatically set via template haskell functions. You  really shouldn'+t use this option yourself unless you have  to. > Register passed to the command. Stringliteral: "\"" ?Stringliteral sync or async @AThis option detemines how neovim should behave when calling some ! functionality on a remote host. AGCall the function and wait for its result. This is only synchronous on > the neovim side. This means that the GUI will (probably) not 1 allow any user input until a reult is received. BECall the functionality entirely for its side effects and do not wait A for it to finish. Calling a functionality with this flag set is H completely asynchronous and nothing is really expected to happen. This F is why a call like this is called notification on the neovim side of  things. C7Functionality specific functional description entries. FAll fields which are directly specified in these constructors are not M optional, but can partialy be generated via the Template Haskell functions. G The last field is a data type that contains all relevant options with  sensible defaults, hence  can be used as an argument. DCExported autocommand. Will call the given function if the type and  filter match. ENB: 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 call  * Options for the autocmd (use  here if you don't want to change anything) EExported Command. Callable via :Name arg1 arg2. ; Name of the command (must start with an uppercase letter)  * Options to configure neovim'#s behavior for calling the command F Exported function. Callable via call name(arg1,arg2). < Name of the function (must start with an uppercase letter) J * Option to indicate how neovim should behave when calling this function GEssentially just a string. ISmart constructor for 7%. This sorts the command options and J removes duplicate entries for semantically the same thing. Note that the N smallest option stays for whatever ordering is defined. It is best to simply + not define the same thing multiple times. 7&'()*+,-./0123456789:;<=>?@ABCDEFGHI$&'()*+,-./0123456789:;<=>?@ABCDEFGHI%CFEDGH@BA9?>=<;:783654-./0128I()*+,&'&'()*+,-./0123654789?>=<;:@BACFEDGHI,Classes used for Inter Plugin Communication GHC experimentalwoozletoff@gmail.comNone JA notification is similar to a N. It essentially does the same K thing, but the function is only called for its side effects. This type of N message is sent by neovim if the caller there does not care about the result  of the computation. LName of the function to call. MArguments for the function. NJA request is a data type containing the method to call, its arguments and L an identifier used to map the result to the function that has been called. PName of the function to call. Q<Identifier to map the result to a function call invocation. RArguments for the function. SDHaskell representation of supported Remote Procedure Call messages. T-Method name, parameters, callback, timestamp U'This class allows type safe casting of W to an actual message. ' The cast is successful if the type you'%re expecting matches the type in the  W> wrapper. This way, you can subscribe to an arbitrary message M type withouth having to pattern match on the constructors. This also allows O plugin authors to create their own message types without having to change the  core code of nvim-hs. VETry to convert a given message to a value of the message type we are ! interested in. Will evaluate to } for any other type. W(Taken from xmonad and based on ideas in / An Extensible Dynamically-Typed  Hierarchy of Exceptions/, Simon Marlow, 2006. KUser-extensible messages must be put into a value of this type, so that it  can be sent to other plugins. JKLMNOPQRSTUVWX`wJKLMNOPQRSTUVWXWXUVSTNOPQRJKLM JKLMNOPQRSTUVWX'Communication between Haskell processes/threads  experimentalwoozletoff@gmail.comNoneVWXWXV+Abstract description of the plugin provider's internal context GHC experimentalwoozletoff@gmail.comNone _;The state that the plugin provider wants to transition to. `*The plugin provider started successfully. aAThe plugin provider failed to start or some other error occured. bRestart the plugin provider. cQuit the plugin provider. dFThis GADT is used to share informatino between stateless and stateful I plugin threads since they work fundamentally in the same way. They both J contain a function to register some functionality in the plugin provider L as well as some values which are specific to the one or the other context. gDA wrapper for a reader value that contains extra fields required to O communicate with the messagepack-rpc components and provide necessary data to . provide other globally available operations. NNote that you most probably do not want to change the fields prefixed with an  underscore. i=A queue of messages that the event handler will propagate to # appropriate threads and handlers. j#The main thread will wait for this  to be filled with a value > and then perform an action appropriate for the value of type  _. kSince nvim-hs must have its Neovim.RPC.SocketReader and  Neovim.RPC.EventHandler, running to determine the actual channel id  (i.e. the 8 value here) this field can only be set properly later. - Hence, the value of this field is put in an . G Name that is used to identify this provider. Assigning such a name is " done in the neovim config (e.g. ~/.nvim/ nvimrc). lThis 9 is used to generate uniqe function names on the side of  nvim-hs. This is useful if you don't want to overwrite existing / functions or if you create autocmd functions. mDThis map is used to dispatch received messagepack function calls to  it's appropriate targets. nBIn a registered functionality this field contains a function (and H possibly some context dependent values) to register new functionality. o>Plugin author supplyable custom configuration. Queried on the  user-facing side with Y or Z. pKA function map is a map containing the names of functions as keys and some I context dependent value which contains all the necessary information to , execute that function in the intended way. KThis type is only used internally and handles two distinct cases. One case M is a direct function call, wich is simply a function that accepts a list of  $ values and returns a result in the x context. The second M 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 G state is stored for as long as the plugin provider is running and not  restarted.) q/Type of the values stored in the function map. rLThis data type is used to dispatch a remote function call to the appopriate  recipient. ss4 functions are handled within a special thread, the  B is the communication endpoint for the arguments we have to pass. tt8 functions are simply executed with the sent arguments. uExceptions specific to nvim-hs. vHSimply error message that is passed to neovim. It should currently only  contain one line of text. wConvenience alias for x () (). xDThis is the environment in which all plugins are initially started.  Stateless functions use '()'. for the static configuration and the mutable 6 state and there is another type alias for that case: w. LFunctions have to run in this transformer stack to communicate with neovim. L If parts of your own functions dont need to communicate with neovim, it is K 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 Y for the InternalConfig. |Same as Z for the InternalConfig. } Initialize a x context by supplying an InternalEnvironment. ~EFork a neovim thread with the given custom config value and a custom ; state. The result of the thread is discarded and only the  is  returend immediately. J FIXME This function is pretty much unused and mayhave undesired effects, F namely that you cannot register autocmds in the forked thread. LCreate 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 q values. KConvenient helper to create a new config for the given state and read-only  config.  Sets the n field to }.  Create a new InternalConfig+ 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. 7User facing instance declaration for the reader state. *_`abcdefghijklmnopqrstuvwxyz{|}~$_`abcdefghijklmnopqrstuvwxyz{|}~$xyz{|wuv}~rtsqpghijklmnodfe_cba`_cba`dfeghijklmnopqrtsuvwxyz{|}~The Neovim context  experimentalwoozletoff@gmail.comNone specialized to ,. If you do not care about pretty printing,  you can simply use $ in front of your string or use the  OverloadedStrings) extension to specify the error message. +Initiate a restart of the plugin provider. 1Initiate the termination of the plugin provider. YZ[\]^pquvwx}~xwuvpq}~YZ\^[] LSplit module that can import Neovim.Context without creating import circles GHC experimentalwoozletoff@gmail.comNone- values are wraped inside this data type via  so that ) we can put plugins in an ordinary list. AThis data type contains meta information for the plugin manager. KThis 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 < in some nice blankets, so that we can put them in a simple  list.   /The user editable and compilable configuration  experimentalwoozletoff@gmail.comNoneKThis 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. CThe list of plugins. The IO type inside the list allows the plugin F author to run some arbitrary startup code before creating a value of  type . !Set the general logging options. 4Internally used field. Changing this has no effect. Used by Dyre! for storing compilation errors.   Utility functions GHC experimentalwoozletoff@gmail.comNoneIExecute the given action with a changed set of environment variables and ; restore the original state of the environment afterwards.  with a monadic predicate.  with a monadic predicate.  #Common functons for the RPC module  experimentalwoozletoff@gmail.comNone KSimple data type defining the kind of socket the socket reader should use. 5Use an IP socket. First argument is the port and the  second is the host name. Use a unix socket. 5Read the connection information from the environment  variable NVIM_LISTEN_ADDRESS. ;Use the handle for receiving msgpack-rpc messages. This is > suitable for an embedded neovim which is used in test cases. ?Things shared between the socket reader and the event handler. CA map from message identifiers (as per RPC spec) to a tuple with a  timestamp and a 0 that is used to communicate the result back to  the calling thread. HCreate a new basic configuration containing a communication channel for I remote procedure call events and an empty lookup table for functions to  mediate.  Create a $ from the given socket description. (The handle is not automatically closed. CClose the handle and print a warning if the conduit chain has been  interrupted prematurely.  .Data types and classes for the RPC components GHC experimentalwoozletoff@gmail.comNone See https: github.com msgpack-rpc msgpack-rpcblobmaster/ spec.md for . details about the msgpack rpc specification. ;Notification in the sense of the msgpack rpc specification 6Response in the sense of the msgpack rpc specifcation  Parameters - * Mesage identifier which matches a request  *  an error  or a result  6Request in the sense of the msgpack rpc specification  Parameters I * Message identifier that has to be put in the response to this request  * Function name  * Function arguments  Functions for calling functions  experimentalwoozletoff@gmail.comNone Simply fail and call , in case an unexpected exception is thrown. M This fails with a runtime exception. It is used by the Template Haskell API M generator for functions that are defined as not being able to fail. If this * exception occurs, it is a bug in neovim. KStrip the error result from the function call. This should only be used by D the Template Haskell API generated code for functions that declare  themselves as unfailable. )Helper function that concurrently puts a U# in the event queue and returns an ! action that returns the result. Helper function similar to ( that throws a runtime exception if the  result is an error object. ECall a neovim function synchronously. This function blocks until the  result is available. Helper function similar to ( that throws a runtime exception if the  result is an error object. Lifted variant of . 'Wait for the result of the STM action. 2This action possibly blocks as it is an alias for   i%oSTM -> ioSTM >>= liftIO . atomically.  Variant of  that discards the result. Wait for the result of the  action and call  . (loc++) . show " if the action returned an error.  that discards the result. -Send the result back to the neovim instance. For better error messages Parameters in an  array 1result value of the call or the thrown exception  Prefix error message with this. Function call to neovim Event handling loop  experimentalwoozletoff@gmail.comNone9Convenient monad transformer stack for the event handler HThis function will establish a connection to the given socket and write  msgpack-rpc requests to it.           (Parser for the msgpack output stram API  experimentalwoozletoff@gmail.comNone 9This data type represents the top-level structure of the nvim --api-info  output. 9The error types are defined by a name and an identifier. #Extension types defined by neovim. >The remotely executable functions provided by the neovim api. HThis 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. 'Indicator whether the function can fail/throws exceptions. 5Indicator whether the this function is asynchronous. Functions return type. Run nvim --api-info and parse its output.  Extract a  from on .  Works on  ObjectBinary and  ObjectString constructor.  Extract an w from an Object. & !"#$%&'()*+,-./0123  !"#$%&'()*+,-./0123'Template Haskell API generation module  experimentalwoozletoff@gmail.comNone4:Simply data type used to identify a string-ish type (e.g. , 5,  6 for a value of type. 71Generate the API types and functions provided by nvim --api-info. IThe provided map allows the use of different Haskell types for the types 6 defined in the API. The types must be an instance of   and they F must form an isomorphism with the sent messages types. Currently, it * provides a Convenient way to replace the String type with 5,  6 or . 8-Default type mappings for the requested API. 98This function will create a wrapper function with neovim's function name  as its name. Synchronous function:   - 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:   8 vim_feed_keys :: String -> String -> Bool -> Neovim () & vim_feed_keys keys mode escape_csi =  acallVoid  vim_feed_keys [ toObject keys / , toObject mode 5 , toObject escape_csi  ]   :4 createDataTypeWithObjectComponent SomeName [Foo,Bar]  will create this:    data SomeName = Foo !Object  | Bar !Object - deriving (Typeable, Eq, Show)   ;If the first parameter is mkName NeovimException, this function will  generate "instance Exception NeovimException. <*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 3 fromObject (ObjectExt 1 bs) = return $ Bar bs 3 fromObject (ObjectExt 2 bs) = return $ Quz bs  fromObject o = Left $ ,Object is not convertible to: Foo Received:    show o   KDefine an exported function by providing a custom name and referencing the  function you want to export. 9Note that the name must start with an upper case letter.  Example:  $(function "MyExportedFunction" 'myDefinedFunction) Sync  >Define an exported function. This function works exactly like , J but it generates the exported name automatically by converting the first  letter to upper case. =Given a value of type >., test whether it can be classified according  to the constructors of 4.  Similarly to 3, this function is used to export a command with a  custom name. 9Note that commands must start with an upper case letter. NDue to limitations on the side of (neo)vim, commands can only have one of the 2 following five signatures, where you can replace  with 6  or 5 if you wish:  - -> x r st ()  - -> ?  -> x r st ()  - ->  -> x r st ()  - -> [] -> x r st ()  - ->  -> [] -> x r st ()  Example:  $(command "RememberThePrime" 'someFunction) [:]  GNote that the list of command options (i.e. the last argument) removes N duplicate options by means of some internally convenient sorting. You should * simply not define the same option twice. =Define an exported command. This function works exactly like , but M it generates the command name by converting the first letter to upper case. FThis function generates an export for autocmd. Since this is a static L registration, arguments are not allowed here. You can, of course, define a G fully applied function and pass it as an argument. If you have to add + autocmds dynamically, it can be done with  addAutocmd.  Example:   5 someFunction :: a -> b -> c -> d -> Neovim r st res  someFunction = ...  theFunction :: Neovim r st res $ theFunction = someFunction 1 2 3 4   $(autocmd 'theFunction) def def is of type AutocmdOptions. Note that you have to define  theFunction in a different module due to  the use of Template Haskell. @Generate a function of type [Object] -> Neovim' Object from the argument  function.  The function    add :: Int -> Int -> Int  add = (+)    will be converted to    args -> case args of  [x,y] -> case pure add  * fromObject x  * fromObject y of  Left e -> err $ !Wrong type of arguments for add:  ++ e " Right action -> toObject  $ action  _ -> err $ #Wrong number of arguments for add:  ++ show xs   4ABCDE78F9:;<=@sGHItuvwxyz{|JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%784EDCBA78F9:;<=@String based API  experimentalwoozletoff@gmail.comNonePOOK+Plugin and functionality registration code GHC experimentalwoozletoff@gmail.comNoneGCallthe vimL functions to define a function, command or autocmd on the  neovim side. Returns ! if registration was successful. 7Note that this does not have any effect on the side of nvim-hs. LReturn or retrive the provider name that the current instance is associated  with on the neovim side.  1Register a functoinality in a stateless context.  HRegister an autocmd in the current context. This means that, if you are L currently in a stateful plugin, the function will be called in the current M thread and has access to the configuration and state of this thread. If you M need that information, but do not want to block the other functions in this H thread, you have to manually fork a thread and make the state you need  available there. If you don'1t care abou the state (or your function has been , appield to all the necessary state (e.g. a  to share the rusult), then  you can also call / which will register a stateless function that I only interacts with other threads by means of concurrency abstractions. 7Note that the function you pass must be fully applied. ,Note beside: This function is equivalent to  if called from a  stateless plugin thread. Add a stateless autocmd. See   for more details. 8Create a listening thread for events and add update the p with  the corresponding !s (i.e. communication channels).      -The event to register to (e.g. BufWritePost) #Fully applied function to register A  if the registration worked 9:;<=>?@AB       @BA9?>=<;:        @The component which reads RPC messages from the neovim instance  experimentalwoozletoff@gmail.comNoneGThis 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.md KAct upon the received request or notification. The main difference between K the two is that a notification does not generate a reply. The distinction B between those two cases is done via the first paramater which is ? the  function call identifier. %Wrapper for the actual main function  experimentalwoozletoff@gmail.comNoneA  function receives the s of all running G threads which have been started by the plugin provider as well as the  g with the custom field set to . These information H can be used to properly clean up a session and then do something else. O The transition handler is first called after the plugin provider has started. *This is essentially the main function for nvim-hs, at least if you want  to use  Config.Dyre for the configuration. FThis 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. JGeneric main function. Most arguments are optional or have sane defaults. EIf the plugin provider is started with dyre, this handler is used to  handle a restart. See nvim-hs executables --help function or   +API for interacting with the quickfix list GHC experimentalwoozletoff@gmail.comNone !Create a new list. ";Replace current list (or create a new one if none exists). #DAdd items to the current list (or create a new one if none exists). 'JQuickfix list item. The parameter names should mostly conform to those in  :h setqflist()6. Some fields are merged to explicitly state mutually : exclusive elements or some other behavior of the fields. see 06 for creating a value of this type without typing too  much. )DSince the filename is only used if no buffer can be specified, this  field is a merge of bufnr and filename. *3Line number or search pattern to locate the error. +BA tuple of a column number and a boolean indicating which kind of  indexing should be used. ( means that the visual column should be  used.  means to use the byte index. ,Error number. -Description of the error. .Type of error. /This is a wrapper around neovim's  setqflist(). strType can be any & string that you can append to (hence ) that is also an instance  of  !. You can e.g. use the plain old . 0 Create a '. by providing the minimal amount of arguments  needed.  !"#$%&'()*+,-./0buffer of file name line number or pattern  !"#$%&'()*+,-./0/'()*+,-.$&%0 #"! #"!$&%'()*+,-./0DInternals for a config helper plugin that helps recompiling nvim-hs GHC experimentalwoozletoff@gmail.comNone!Simple function that will return Pong if the plugin provider is  running. JRecompile the plugin provider and put comile errors in the quickfix list. JNote that restarting the plugin provider implies compilation because Dyre N does this automatically. However, if the recompilation fails, the previously N 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. ;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:   5Helper plugin to ease recompiling the nvim-hs config GHC experimentalwoozletoff@gmail.comNone1111#API for the neovim plugin provider nvim-hs GHC (due to Template Haskell) experimentalwoozletoff@gmail.comNone2"Default configuration options for nvim-hs. If you want to keep the @ default plugins enabled, you can define you rconfig like this:   main =  2 9 { plugins = myPlugins ++ plugins defaultConfig  } 2tuvwxyz{  !"#$%()*+,-./01234569:;<>?@ABYZ[\]^uvwx 2cxw2  !"#%$@BA9?><;:3654-./012()*+, YZ[\^]uv 24Utilities to debug Neovim and nvim-hs functionality GHC experimentalwoozletoff@gmail.comNone3Run a x function. LThis function connects to the socket pointed to by the environment variable  $NVIM_LISTEN_ADDRESS7 and executes the command. It does not register itself J as a real plugin provider, you can simply call neovim-functions from the  module Neovim.API.String this way. KTip: If you run a terminal inside a neovim instance, then this variable is  automatically set. 4Run a w function.    debug' a = fmap fst  $ debug () () a See documentation for 3. 5EThis function is intended to be run _once_ in a ghci session that to 6 give a REPL based workflow when developing a plugin. 5Note that the dyre-based reload mechanisms, i.e. the  Neovim.Plugin.ConfigHelper" plugin, is not started this way. JTo 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) <- 5 }  8 cfg $ vim_call_function " getqflist" []   ( ( []))   :r  (tids, cfg) <- 5 } 6+Quit a previously started plugin provider. 7)Restart the development plugin provider. 8(Convenience function to run a stateless x function. 9.Print the global function map to the console. 3456789tuvwxyz{  !"#$%()*+,-./01234569:;<>?@ABYZ[\]^uvwx} 23456789345679}83456789Testing functions GHC experimentalwoozletoff@gmail.comNoneType synonym for x. :Run the given x+ action according to the given parameters. M The embedded neovim instance is started without a config (i.e. it is passed  -u NONE). EIf 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. :.Optional path to a file that should be opened 8Maximum time (in seconds) that a test is allowed to run Read-only configuration State  Test case ::: ! " # $ % & ' ( )*+,,-./0123456756856956:56;56<56=56>56?56@56A56BCDECDFGHIJKLMNOOPQRSSTUVWXYZ[\]^_`abcdefghijklmnoopqrrstuvvwxyy2z{2z|2}~2}2}2}                w o  r     , !"#$%&'()*+,-./0123456789:;<=>?F@ABCDEFGHIJKLMNOPQPRPSPTPUPVPWPXPYPZP[P\P]P^P_P`PaPbPcPdPePfPgPhijklmnopqrstuvwxyz{|}~MMMMMMMMMMM\     MMMM !/0" #M$%M$&M'(M)* + , -.M/01M2M34456789:;<=>N?@ABCDE:>FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmMnopqrstuMvMwxMyzM{|M{}M{}M{~M{~M{M{M{M{M{M{M{M{M{M{MMMMMMMMMMMMMMMMMMMMMMMMM M M M M M M M M M M M M M ,,MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM M M M M M M$ MM) nvim-hs-0.0.6Neovim Neovim.LogNeovim.Plugin.StartupNeovim.ContextNeovim.ClassesNeovim.Plugin.ClassesNeovim.Plugin.IPC.ClassesNeovim.Context.InternalNeovim.Plugin.Internal Neovim.Config Neovim.UtilNeovim.RPC.CommonNeovim.RPC.ClassesNeovim.RPC.FunctionCallNeovim.RPC.EventHandlerNeovim.API.String Neovim.PluginNeovim.RPC.SocketReader Neovim.MainNeovim.QuickfixNeovim.Plugin.ConfigHelper Neovim.Debug Neovim.TestNeovim.Plugin.IPCNeovim.API.Parser Neovim.API.TH#Neovim.Plugin.ConfigHelper.Internaldata-default-class-0.0.1Data.Default.Classdefhslogger-1.2.9 System.LogPriorityWARNINGNOTICEINFOERROR EMERGENCYDEBUGCRITICALALERT disableLogger withLogger StartupConfig dyreParamsghcEnvironmentVariablestransformers-0.4.3.0Control.Monad.IO.ClassliftIO mtl-2.2.1Control.Monad.Error.Class throwErrormessagepack-0.5.0Data.MessagePack ObjectUInt ObjectString ObjectNil ObjectMap ObjectInt ObjectFloat ObjectExt ObjectDouble ObjectBool ObjectBinary ObjectArrayObjectansi-wl-pprint-0.6.7.3Text.PrettyPrint.ANSI.LeijenDoctext NvimObjecttoObjectfromObjectUnsafe fromObject Dictionary+:HasFunctionNamenameAutocmdOptions acmdPattern acmdNested acmdGroupCommandArgumentsbangrangecountregisterRangeSpecification RangeCount WholeFile CurrentLineCommandOptionsgetCommandOptions CommandOptionCmdBangCmdCountCmdRangeCmdNargs CmdRegisterCmdSync SynchronousSyncAsyncFunctionalityDescriptionAutocmdCommandFunction FunctionNameFmkCommandOptions Notification notMethodnotArgsRequest reqMethodreqIdreqArgs FunctionCallMessage fromMessage SomeMessageControl.Monad.Reader.ClassaskasksControl.Monad.State.ClassputgetmodifygetsStateTransition InitSuccessFailureRestartQuitPluginSettingsStatefulSettingsStatelessSettingsConfig eventQueue transitionTo providerName uniqueCounterglobalFunctionMappluginSettings customConfig FunctionMapFunctionMapEntry FunctionTypeStateful StatelessNeovimException ErrorMessageNeovim'unNeovimask'asks' runNeovim forkNeovimnewUniqueFunctionName mkFunctionMap retypeConfig newConfigerrerrOnInvalidResultrestartquit NeovimPluginPluginexportsstatefulExportsExportedFunctionalityEFgetDescription getFunction wrapPlugin NeovimConfigplugins logOptions errorMessagewithCustomEnvironmentwhenMunlessMoneLineErrorMessage SocketTypeTCP UnixSocket EnvironmentStdout RPCConfig recipients newRPCConfig createHandle cleanUpHandleResponseacallacall'scallscall' atomically'waitwait'waitErrwaitErr'respondrunEventHandlerfunction function'commandcommand'autocmdWindowTabpageBufferNeovimExceptionGenNeovimValidationbuffer_line_countbuffer_get_linebuffer_set_linebuffer_del_linebuffer_get_line_slicebuffer_set_line_slicebuffer_get_varbuffer_set_varbuffer_get_optionbuffer_set_optionbuffer_get_numberbuffer_get_namebuffer_set_namebuffer_is_valid buffer_insertbuffer_get_mark vim_command vim_feedkeys vim_inputvim_replace_termcodesvim_command_outputvim_evalvim_call_function vim_strwidthvim_list_runtime_pathsvim_change_directoryvim_get_current_linevim_set_current_linevim_del_current_line vim_get_var vim_set_var vim_get_vvarvim_get_optionvim_set_option vim_out_write vim_err_writevim_report_errorvim_get_buffersvim_get_current_buffervim_set_current_buffervim_get_windowsvim_get_current_windowvim_set_current_windowvim_get_tabpagesvim_get_current_tabpagevim_set_current_tabpage vim_subscribevim_unsubscribevim_name_to_colorvim_get_color_mapvim_get_api_infotabpage_get_windowstabpage_get_vartabpage_set_vartabpage_get_windowtabpage_is_validwindow_get_bufferwindow_get_cursorwindow_set_cursorwindow_get_heightwindow_set_heightwindow_get_widthwindow_set_widthwindow_get_varwindow_set_varwindow_get_optionwindow_set_optionwindow_get_positionwindow_get_tabpagewindow_is_validstartPluginThreadsregisterInStatelessContextregisterInStatefulContext addAutocmd addAutocmd'runSocketReader parseParamsTransitionHandlerCommandLineOptionsOpthostPortunixenvlogOptslogger optParseroptsneovimrealMainrunPluginProvider finishDyreQuickfixActionNewReplaceAppendQuickfixErrorTypeErrorWarningQuickfixListItemQFItem bufOrFile lnumOrPatterncolnr errorType setqflistquickfixListItemplugin defaultConfigdebugdebug' develMain quitDevelMainrestartDevelMain runNeovim'printGlobalFunctionMaptestWithEmbeddedNeovimbase System.IOputStrLnSystem.Log.LoggerLoggerwarningMupdateGlobalLogger traploggingsetLevel setHandlerssaveGlobalLoggerrootLoggerName removeHandlerremoveAllHandlersnoticeMlogMlogLinfoM getRootLogger getLoggergetLevelerrorM emergencyMdebugM criticalM clearLevelalertM addHandler$fNvimObjectEither$fNvimObject(,,,,,,,,)$fNvimObject(,,,,,,,)$fNvimObject(,,,,,,)$fNvimObject(,,,,,)$fNvimObject(,,,,)$fNvimObject(,,,)$fNvimObject(,,)$fNvimObject(,)$fNvimObjectDoc$fNvimObjectObject$fNvimObjectByteString$fNvimObjectText$fNvimObjectMap$fNvimObjectMaybe$fNvimObject[]$fNvimObject[]0$fNvimObjectChar$fNvimObjectInt$fNvimObjectWord8$fNvimObjectWord16$fNvimObjectWord32$fNvimObjectWord64$fNvimObjectWord$fNvimObjectInt8$fNvimObjectInt16$fNvimObjectInt32$fNvimObjectInt64$fNvimObjectInteger$fNvimObjectDouble$fNvimObjectBool$fNvimObject()GHC.IntInt8Int16Int32Int64ghc-prim GHC.TypesWordGHC.WordWord8Word16Word32Word64 Data.MaybeNothingJustTrueFalseGHC.BaseString)$fHasFunctionNameFunctionalityDescription$fNvimObjectAutocmdOptions$fDefaultAutocmdOptions$fPrettyAutocmdOptions$fNvimObjectCommandArguments$fDefaultCommandArguments$fPrettyCommandArguments$fNvimObjectRangeSpecification$fPrettyRangeSpecification$fNvimObjectCommandOptions$fPrettyCommandOptions$fIsStringCommandOption$fPrettyCommandOption$fNvimObjectSynchronous$fIsStringSynchronous$fPrettySynchronous $fPrettyFunctionalityDescription$fPrettyFunctionName$fPrettyNotification$fMessageNotification$fPrettyRequest$fMessageRequest$fPrettyFunctionCall$fMessageFunctionCall time-1.4.0.1Data.Time.Format formatTimeformatCharacter FormatTimeData.Time.Format.Parse readsTimereadTime parseTime buildTime ParseTimeData.Time.LocalTime.LocalTimeutcToLocalZonedTime getZonedTimezonedTimeToUTCutcToZonedTimelocalTimeToUT1ut1ToLocalTimelocalTimeToUTCutcToLocalTimelocalTimeOfDaylocalDay LocalTime zonedTimeZonezonedTimeToLocalTime ZonedTimeData.Time.LocalTime.TimeOfDaytimeOfDayToDayFractiondayFractionToTimeOfDaytimeOfDayToTimetimeToTimeOfDaylocalToUTCTimeOfDayutcToLocalTimeOfDaymakeTimeOfDayValidmiddaymidnighttodSectodMintodHour TimeOfDayData.Time.LocalTime.TimeZonegetCurrentTimeZone getTimeZoneutctimeZoneOffsetStringtimeZoneOffsetString'hoursToTimeZoneminutesToTimeZone timeZoneNametimeZoneSummerOnlytimeZoneMinutesTimeZoneData.Time.ClockgetCurrentTimeData.Time.Clock.UTCDiff diffUTCTime addUTCTimeData.Time.Clock.UTC utctDayTimeutctDayUTCTimeNominalDiffTimeData.Time.Calendar.GregorianaddGregorianYearsRollOveraddGregorianYearsClipaddGregorianMonthsRollOveraddGregorianMonthsClipgregorianMonthLength showGregorianfromGregorianValid fromGregorian toGregorianData.Time.Calendar.OrdinalDate isLeapYearData.Time.Calendar.DaysdiffDaysaddDaystoModifiedJulianDayModifiedJulianDayDayData.Time.Calendar.PrivateNumericPadOptionData.Time.Clock.ScalepicosecondsToDiffTimesecondsToDiffTimegetModJulianDate ModJulianDate UniversalTimeDiffTimeGHC.MVarMVarInt stm-2.4.4Control.Concurrent.STM.TMVarTMVar GHC.Conc.SyncTVarControl.Concurrent.STM.TQueueTQueueIOThreadId$fMonadReaderrNeovim$fPrettyFunctionType$fPrettyNeovimException$fIsStringNeovimException$fExceptionNeovimException$fMonadBaseIONeovim GHC.ExceptionthrowMonadIO&$fHasFunctionNameExportedFunctionality Control.MonadwhenunlessGHC.IO.Handle.TypesHandle Data.EitherEither$fPrettyMessage$fNvimObjectMessage$fMessageMessageunexpectedExceptionGHC.ErrerrorwithIgnoredExceptionSTM atomically EventHandlerrunEventHandlerContexteventHandlerSource eventHandleryield' handleMessage NeovimAPI errorTypes customTypes functionsNeovimFunction parameterscanFailasync returnTypeparseAPI oToStringoInt NeovimTypeVoid NestedType SimpleType extractAPI decodeAPIoMapoLookupoLookupDefaultoArroToBoolextractErrorTypesextractTypeNameAndIDextractCustomTypesextractFunctionstoParameterlistextractFunction parseTypepTypepVoidpSimplepArraypNumArgType text-1.2.1.3Data.Text.InternalTextbytestring-0.10.0.2Data.ByteString.Internal ByteString generateAPIdefaultAPITypeToHaskellTypeMapcreateFunction%createDataTypeWithByteStringComponentexceptionInstancecustomTypeInstanceclassifyArgTypetemplate-haskellLanguage.Haskell.TH.SyntaxTypeMaybefunctionImplementation OtherTypeCommandArgumentsTypeOptionalListOfStringyTypes StringyTypeapiTypeToHaskellTypeassert Data.DataDataData.Typeable.InternalTypeableControl.Exception.Base mapExceptionPatternMatchFail RecSelError RecConError RecUpdError NoMethodErrorNonTerminationNestedAtomicallyGHC.IO.ExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAssertionFailed StackOverflow HeapOverflow ThreadKilled UserInterruptAsyncExceptionIndexOutOfBoundsUndefinedElementArrayExceptionGHC.IOblockedunblockblockUnmaskedMaskedInterruptibleMaskedUninterruptible MaskingState IOException SomeException fromException toException Exception ErrorCallOverflow UnderflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominatorArithExceptionlifted-base-0.2.3.6Control.Exception.LiftedHandleruninterruptibleMask_uninterruptibleMasktryJusttrythrowTothrowIO onExceptionmask_maskioError handleJusthandlegetMaskingStatefinallyevaluatecatches catchJustcatchbracket_bracketOnErrorbracketallowInterrupt$fExceptionNeovimExceptionGenregisterWithNeovimgetProviderNameregisterStatefulFunctionalityregisterFunctionalityregisterInGlobalFunctionMapresourcet-1.1.6%Control.Monad.Trans.Resource.Internal ReleaseKeymessageHandlerSinkhandleRequestOrNotification SocketHandlerhandleResponse$fDefaultCommandLineOptions Data.MonoidMonoid$fNvimObjectQuickfixAction$fNvimObjectQuickfixListItem$fNvimObjectQuickfixErrorType pingNvimhsrecompileNvimhs restartNvimhs pLocationparseQuickfixItemspQuickfixListItempShortDesrciptionpLongDescription spaceChar blankLinepIntControl.Applicative ApplicativeoptionalliftA3liftA2liftA<**><**><*>puremanysome<|>empty AlternativegetConstConst unwrapMonad WrapMonad WrappedMonad unwrapArrow WrapArrow WrappedArrow getZipListZipList Data.Functor<$><>mconcatmappendmemptygetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductgetFirstFirstgetLastLastvoid<$RightSecondsstartEmbeddedNvim