~7\      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq r s t u v w x y z { | } ~   Debugging facilities(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneDisable logging to stderr.Initialize 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 = withLogger "home9dude/nvim.log" Debug $ do putStrLn "Hello, World!" #      !"#+Classes used for Inter Plugin Communication(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHC Safe-Inferred:MfTry to convert a given message to a value of the message type we are interested in. Will evaluate to $ 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.7Internally used parts of the inter plugin communication(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone+ 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.Argumentse 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 and parameters.8Response sent to indicate the result of a function call.identfier of the message as Word32 Error value Result value,Method name, parameters, callback, timestamp%&'^()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx %&'/Communication between Haskell processes/threads(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimental Safe-InferredThe Neovim context(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone+T&Convenience alias for ' () ().'This is the environment in which all plugins are initially started. Stateless functions use '()' for the static configuration and the mutable state and there is another type alias for that case: &.!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 y in general haskell programs.)Restart the plugin provider.*Quit the plugin provider.+uA wrapper for a reader value that contains extra fields required to communicate with the messagepack-rpc components.-_A queue of messages that the event handler will propagate to appropriate threads and handlers..#The main thread will wait for this zZ to be filled with a value and then perform an action appropriate for the value of type (./wName that is used to identify this provider. Assigning such a name is done in the neovim config (e.g. ~/.nvim/nvimrc).0FPlugin author supplyable custom configuration. It can be queried via myConf.2 Initialize a ' context by supplying an InternalEnvironment.3Fork 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.4 throw . ErrorMessage5bRetrieve something from the configuration with respect to the first function. Works exactly like |.6;Retrieve the Cunfiguration (i.e. read-only state) from the ' context.7*Initiate a restart of the plugin provider.80Initiate the termination of the plugin provider.$%&'()*+,-./012345678}~ !"#$%&'()*+,-./012345678561! "#'&$%+,-./023478(*)$%&'(*)+,-./012345678}=Type classes used for conversion of msgpack and Haskell types(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone246HMT9Conversion from J files to Haskell types and back with respect to neovim's interpretation.=A 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.9:;<=(9:;<=9:;<=9:;<=)Classes and data types related to plugins(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNone:MTA@This data type contains meta information for the plugin manager.E5Conveniennce class to extract a name from some value.IZOption to indicate whether vim shuould block until the function has completed. (default: _)J#Pattern to match on. (default: "*")K Nested autocmd. (default: False)See :h autocmd-nestedLYou 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.NpNothing 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 ( ).O&Range passed from neovim. Only set if Z4 was used in the export declaration of the command. Examples: *  Just (1,12)P$Count passed by neovim. Only set if Y4 was used in the export declaration of the command.QRegister that the command canshould must use.Newtype wrapper for a list of Wy. Any properly constructed object of this type is sorted and only contains zero or one object for each possible option.WOptions for commands.vSome 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 W} value. See the documentation for each value on how these strings should look like (Both versions are compile time checked.)XCommand handles a bangStringliteral: "!"YACommand handles a count. The argument defines the default count.-Stringliteral: string of numbers (e.g. "132")Z'Determines how neovim passes the range.Stringliterals: "%" for T9, "," for line and ",123" for 123 lines.[,Command takes a specific amount of argumentsuAutomatically set via template haskell functions. You really shouldn't use this option yourself unless you have to.\Register passed to the command.Stringliteral: """]"Should neovim wait for an answer (_)? Stringliteral: "sync" or "async"^aThis option detemines how neovim should behave when calling some functionality on a remote host._6Call the function and wait for its result. This is only synchronous on the neovim side. For comands it means that the GUI will (probably) not allow any user input until a reult is received. Functions run asynchronously inside neovim (or in one of its plugin providers) can use these functions concurrently.`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.a6Functionality 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.bQExported autocommand. Will call the given function if the type and filter match.NB: Since we are registering this on the Haskell side of things, the number of accepted arguments should be 0. TODO Should this be enforced somehow? Possibly via the TH generator.)Type of the autocmd (e.g. "BufWritePost")Name for the function to callcExported 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 commandd 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 functioneVThis data type is used in the plugin registration to properly register the functions.gExtract the description of an e.hExtract the function of an e.jWrap a AB in some nice blankets, so that we can put them in a simple list.9?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij,?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij,efhgadcbEF?@ABCDj^`_W]\[ZYXRUTSLMNOPQViGHIJK?@ABCDEFGHIJKLMNOPQRUTSVW]\[ZYX^`_adcbefghij.The user editable and compilable configuration(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNonemThe 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 ?.nUsed by Dyre for storing compilation errors.o Set the general logging options.pParmaeters used by Dyre. This is only used for the Neovim.Plugin.ConfigHelper plugin.klmnop    >klmnopklmnopklmnop "Common functons for the RPC module(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneHMTqJSimple data type defining the kind of socket the socket reader should use.rNUse an IP socket. First argument is the port and the second is the host name.sUse a unix socket.t?Read the connection information from the environment variable NVIM_LISTEN_ADDRESS.uxUse the handle for receiving msgpack-rpc messages. This is suitable for an embedded neovim which is used in test cases.v>Things shared between the socket reader and the event handler.xTA 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.yjA map that contains the function names which are registered to this plugin manager. Putting the map in a e ensures that all functionality is registered properly before answering to requests send by neovim.zWThis 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.||7 functions are simply executed with the sent arguments.}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.)~Create a new basic configuration containing a communication channel for 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.qrstuvwxyz{|}~qrstuvwxyz{|}~}z|{vwxy~qutsrqutsrvwxyz|{}~ Functions for calling functions(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneT)Helper function that concurrently puts a Message$ in the event queue and returns an  action that returns the result.ZCall a neovim function synchronously. This function blocks until the result is available.Lifted variant of .&Wait for the result of the STM action.3This action possibly blocks as it is an alias for ' ioSTM -> ioSTM >>= liftIO . atomically. Variant of  that discards the result.Wait for the result of the  action and call 4 . (loc++) . show" if the action returned an error. that discards the result.,Send the result back to the neovim instance. 'Function name for better error messages Function nameParameters in an  array0result value of the call or the thrown exceptionPrefix error message with this.Function call to neovim  Event handling loop(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneBT8Convenient monad transformer stack for the event handlerdThis function will establish a connection to the given socket and write msgpack-rpc requests to it. ?The component which reads RPC messages from the neovim instance(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneBT3Convenient transformer stack for the socket reader.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  the function call identifier.  'Parser for the msgpack output stram API(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone 9This data type represents the top-level structure of the nvim --api-info output.8The 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.:Indicator whether the function can fail/throws exceptions.4Indicator 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 ( from an Object.&&Template Haskell API generation module(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone:Simply data type used to identify a string-ish type (e.g. , ,  for a value of type.1Generate 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 9 and they must form an isomorphism with the sent messages types. Currently, it provides a Convenient way to replace the String@ type with ,  or .,Default type mappings for the requested API.VThis 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 ] 5 createDataTypeWithObjectComponent SomeName [Foo,Bar] will create this: i 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 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 gDefine an exported function by providing a cutom name and referencing the function you want to export.8Note that the name must start with an upper case letter. Example:  $(function MyExportedFunction 'myDefinedFunction) def >Define an exported function. This function works exactly like b, but it generates the exported name automatically by converting the first letter to upper case.Given a value of type F, test whether it can be classified according to the constructors of . Similarly to @, this function is used to export a command with a custom name.8Note that commands must start with an upper case letter.=Define an exported command. This function works exactly like R, but it generates the command name by converting the first letter to upper case.Define an autocmd. This function generates an export for autocmd. Since this is a static registration, arguments are not allowed here. You can of course define a fully applied functions and pass it as an arguments.Generate 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 l(      !"#$%&'()*+,-./012345 9:;<=6789:;<=>?@ABCDEFGHIJKLM String based API(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNone+HMPOTK"Copyright : (c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNoneTN8Create a listening thread for events and add update the } with the corresponding  s (i.e. communication channels).OPN?ABCDWXYZ[\]^_`jj?ABCD^`_W]\[ZYXOPN*API for interacting with the quickfix list(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNoneT Create a new list.:Replace current list (or create a new one if none exists).CAdd items to the current list (or create a new one if none exists).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. / means that the visual column should be used.  means to use the byte index. Error number.Description of the error.-TODO replace with enum, but too lazy for now. Create a 6 by providing the minimal amount of arguments needed.buffer of file nameline number or patternCInternals for a config helper plugin that helps recompiling nvim-hs(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNoneTQ!Simple function that will return Pong$ if the plugin provider is running.RIRecompile the plugin provider and put comile errors in the quickfix list.SNote that restarting the plugin provider implies compilation because Dyre does this automatically. However, if the recompilation fails, the previously compiled bynary is executed. This essentially means that restarting may take more time then you might expect.T: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: QRSUVWXYZT[ QRSUVWXYZT[ QRSUVWXYZT[4Helper plugin to ease recompiling the nvim-hs config(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHCNonejNote that you cannot really use this plugin by hand. It is automatically loaded for all Neovim instances.$Wrapper for the actual main function(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalNoneT*This is essentially the main function for nvim-hs#, at least if you want to use the  Config.Dyre for the configuration..   #API for the neovim plugin provider nvim-hs(c) Sebastian Witte Apache-2.0woozletoff@gmail.com experimentalGHC (due to Template Haskell)None\]^_`(abcdefghijklmnopqrstuvwxyz{|}~  !"#&'4569:<=>?@ABCDGHIJKLMNOPQRSTUWXYZ\]^_`jklmnopI'&klmnop>?@ABCD9:<=  j^`_W]\ZYXRUTSLMNOPQGHIJK65 !#"4 !"#$%&'(()*++,-./01234567869:69;69<69=>?@ABCDDEFGHIJKLMNOPQRSTUVWXYYZZ[\]^__`abccdefghijklmnopqrstuvwxyz{|}~                     > g      !"#$%&'()*+,-./0123456789:;<7=>?@A?@B?@C?DE?DF?DG?DH?DI?JK?JL?JM?JN?JO?JP?JQ?JR?JS?JT?JU?JU?JV?JW?JX?JX?YZ?Y[?Y\?Y]?Y^?Y_?Y`?Ya?Yb?Yc?Yd?Ye?Yf?Yf?gh?gi?gj?gk?gl?gm?gn?go?gp?gq?gr?gr?st?uv?uw?xy?xz?x{?x{?x|?}~?}?}?}?}?}?}?}?}?????????????776M347=7=787VW777            78      ^      !"7#7$%7&'7()7(*7(*7(+7(+7(,7(,7(-7(-7(.7(.7(/7(/7(07(071271371471471571571671671771771871871971:71;71<71=71>71?71@7AB7AC7AD7AE71F7GH7GI7GJ7GK7GL7GM7GM7GN7GO7GP7GQ7GR7GS7GT7GIUVWUVWUVXUVYUVZUV[UV\UV]UV^UV_UV`UVaUVbUVcUVdUVeUVfUVgUVhUViUVjUVkUVlUVmnopqrstuvwxyz7{|7{}7{~7{7=7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7{7777777777777777777777777777777 nvim-hs-0.0.2 Neovim.DebugNeovim.Plugin.IPC.ClassesNeovimNeovim.Plugin.IPC.InternalNeovim.ContextNeovim.ClassesNeovim.Plugin.Classes Neovim.ConfigNeovim.RPC.CommonNeovim.RPC.FunctionCallNeovim.RPC.EventHandlerNeovim.RPC.SocketReaderNeovim.API.String Neovim.PluginNeovim.QuickfixNeovim.Plugin.ConfigHelper Neovim.MainNeovim.Plugin.IPCNeovim.API.Parser Neovim.API.TH#Neovim.Plugin.ConfigHelper.Internal disableLogger withLoggerMessage fromMessage SomeMessagemessagepack-0.4.0Data.MessagePack ObjectString ObjectNil ObjectMap ObjectInt ObjectFloat ObjectExt ObjectDouble ObjectBool ObjectBinary ObjectArrayObject Notification notMethodnotArgsRequest reqMethodreqIdreqArgs RPCMessageNotificationCallResponse FunctionCalltransformers-0.4.3.0Control.Monad.IO.ClassliftIO mtl-2.2.1Control.Monad.Error.Class throwErrorControl.Monad.State.ClassputgetmodifygetsNeovimException ErrorMessageNeovim' QuitActionRestartQuit ConfigWrapper _eventQueue_quit _providerName customConfig eventQueue runNeovim forkNeovimerrasksaskrestartquit NvimObjecttoObjectfromObjectUnsafe fromObject Dictionarydata-default-class-0.0.1Data.Default.Classdef NeovimPluginPluginexportsstatefulExports FunctionNamenameAutocmdOptionsacmdSync acmdPattern acmdNestedCommandArgumentsbangrangecountregisterRangeSpecification RangeCount WholeFile CurrentLinegetCommandOptions CommandOptionCmdBangCmdCountCmdRangeCmdNargs CmdRegisterCmdSync SynchronousSyncAsyncFunctionalityDescriptionAutocmdCommandFunctionExportedFunctionalityEFgetDescription getFunctionmkCommandOptions wrapPlugin NeovimConfigConfigplugins errorMessage logOptions dyreParams SocketTypeTCP UnixSocket EnvironmentStdout RPCConfig recipients functions FunctionTypeStateful Stateless FunctionMap newRPCConfig createHandle cleanUpHandleacallacall'scallscall' atomically'waitwait'waitErrwaitErr'respondrunEventHandlerrunSocketReader parseParamsfunction function'commandcommand'autocmdWindowTabpageBufferNeovimExceptionGenNeovimValidationtabpage_get_windowstabpage_get_vartabpage_set_vartabpage_get_windowtabpage_is_valid 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_infobuffer_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_markwindow_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_valid$fExceptionNeovimExceptionGenstartPluginThreadsQuickfixActionNewReplaceAppendQuickfixListItemQFItem bufOrFile lnumOrPatterncolnrtext errorType setqflistquickfixListItem$fNvimObjectQuickfixAction$fNvimObjectQuickfixListItempluginCommandLineOptionsOpt providerNamehostPortunixenvlogOpts optParseroptsneovimrealMainrunPluginProviderfinishhslogger-1.2.9 System.LogPrioritySystem.Log.LoggerLoggerWARNINGNOTICEINFOERROR EMERGENCYDEBUGCRITICALALERTwarningMupdateGlobalLogger traploggingsetLevel setHandlerssaveGlobalLoggerrootLoggerName removeHandlerremoveAllHandlersnoticeMlogMlogLinfoM getRootLogger getLoggergetLevelerrorM emergencyMdebugM criticalM clearLevelalertM addHandlerbase Data.MaybeNothing$fMessageNotification$fMessageRequest$fMessageRPCMessageGHC.IntInt64 time-1.4.2Data.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-prim GHC.TypesIOGHC.MVarMVar GHC.Conc.SyncThreadIdControl.Monad.Reader.Class$fExceptionNeovimExceptionMonadIO$fNvimObject(,,,,,,,,)$fNvimObject(,,,,,,,)$fNvimObject(,,,,,,)$fNvimObject(,,,,,)$fNvimObject(,,,,)$fNvimObject(,,,)$fNvimObject(,,)$fNvimObject(,)$fNvimObjectObject$fNvimObjectByteString$fNvimObjectText$fNvimObjectMap$fNvimObjectMaybe$fNvimObject[]$fNvimObject[]0$fNvimObjectChar$fNvimObjectInt$fNvimObjectInt16$fNvimObjectInt32$fNvimObjectInt64$fNvimObjectInteger$fNvimObjectDouble$fNvimObjectBool$fNvimObject()Int16Int32JustTrueFalseCommandOptionsGHC.BaseString#$fFunctionNameExportedFunctionality&$fFunctionNameFunctionalityDescription$fNvimObjectAutocmdOptions$fDefaultAutocmdOptions$fNvimObjectCommandArguments$fDefaultCommandArguments$fNvimObjectRangeSpecification$fNvimObjectCommandOptions$fIsStringCommandOption$fNvimObjectSynchronous$fIsStringSynchronous$fDefaultNeovimConfigDefault stm-2.4.4Control.Concurrent.STM.TMVarTMVarControl.Concurrent.STM.TQueueTQueueGHC.IO.Handle.TypesHandleSTM atomicallyunexpectedExceptionwithIgnoredException EventHandlerrunEventHandlerContexteventHandlerSource eventHandleryield' handleMessage SocketHandlermessageHandlerSinkhandleRequestOrNotificationMaybeloggerrunSocketHandlerhandleResponseOrRequesthandleResponsehandleNotification NeovimAPI errorTypes customTypesNeovimFunction parameterscanFaildeferred returnTypeparseAPI oToStringoInt NeovimTypeVoid NestedType SimpleType extractAPI decodeAPIoMapoLookupoLookupDefaultoArroToBoolextractErrorTypesextractTypeNameAndIDextractCustomTypesextractFunctionstoParameterlistextractFunction parseTypepTypepVoidpSimplepArraypNumArgType text-1.2.1.1Data.Text.InternalTextbytestring-0.10.4.0Data.ByteString.Internal ByteString generateAPIdefaultAPITypeToHaskellTypeMapcreateFunction%createDataTypeWithByteStringComponentexceptionInstancecustomTypeInstanceclassifyArgTypetemplate-haskellLanguage.Haskell.TH.SyntaxTypefunctionImplementation OtherTypeCommandArgumentsTypeOptionalStringyTypeListOfStringyTypes StringyTypeapiTypeToHaskellTypeassert Data.DataDataData.Typeable.InternalTypeableControl.Exception.Base mapExceptionPatternMatchFail RecSelError RecConError RecUpdError NoMethodErrorNonTerminationNestedAtomicallyGHC.IO.ExceptionasyncExceptionFromExceptionasyncExceptionToExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAssertionFailedSomeAsyncException StackOverflow HeapOverflow ThreadKilled UserInterruptAsyncExceptionIndexOutOfBoundsUndefinedElementArrayExceptionGHC.IOUnmaskedMaskedInterruptibleMaskedUninterruptible MaskingState IOException GHC.Exceptionthrow SomeException fromException toException Exception ErrorCallOverflow UnderflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominatorArithExceptionlifted-base-0.2.3.6Control.Exception.LiftedHandleruninterruptibleMask_uninterruptibleMasktryJusttrythrowTothrowIO onExceptionmask_maskioError handleJusthandlegetMaskingStatefinallyevaluatecatches catchJustcatchbracket_bracketOnErrorbracketallowInterruptregisterStatefulFunctionalityregisterWithNeovim pingNvimhsrecompileNvimhs restartNvimhs pLocationparseQuickfixItemspQuickfixListItempShortDesrciptionpLongDescription spaceChar blankLinepIntControl.Applicative<*>pure Alternative ApplicativeInt8optionalliftA3liftA2liftA<**><**>manysome<|>emptygetConstConst unwrapMonad WrapMonad WrappedMonad unwrapArrow WrapArrow WrappedArrow getZipListZipList Data.Functor<$> Data.Monoid<>mconcatmappendmemptyMonoidgetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductgetFirstFirstgetLastLast<$