-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell plugin backend for neovim
--   
--   This package provides a plugin provider for neovim. It allows you to
--   write plugins for one of the great editors of our time in the best
--   programming language of our time! ;-)
--   
--   You should find all the documentation you need inside the
--   <a>Neovim</a> module. Most other modules are considered internal, so
--   don't be annoyed if using things from there may break your code!
--   
--   The following modules may also be of interest and they should not
--   change their API: <a>Neovim.Quickfix</a>
--   
--   If you want to write unit tests that interact with neovim,
--   <a>Neovim.Test</a> provides some useful functions for that.
--   
--   If you are keen to debug <i>nvim-hs</i> or a module you are writing,
--   take a look at the <a>Neovim.Debug</a> module.
--   
--   If you spot any errors or if you have great ideas, feel free to open
--   an issue on github.
@package nvim-hs
@version 1.0.0.2

module Neovim.Compat.Megaparsec
type Parser = Parsec Void String


module Neovim.Exceptions

-- | Exceptions specific to <i>nvim-hs</i>.
data NeovimException

-- | Simply error message that is passed to neovim. It should currently
--   only contain one line of text.
ErrorMessage :: (Doc AnsiStyle) -> NeovimException

-- | Error that can be returned by a remote API call. A call of
--   <tt>fromObject</tt> on this value could be converted to a value of
--   <tt>NeovimExceptionGen</tt>.
ErrorResult :: Object -> NeovimException
exceptionToDoc :: NeovimException -> Doc AnsiStyle
instance GHC.Show.Show Neovim.Exceptions.NeovimException
instance GHC.Exception.Exception Neovim.Exceptions.NeovimException
instance Data.String.IsString Neovim.Exceptions.NeovimException


module Neovim.Classes

-- | Conversion from <a>Object</a> files to Haskell types and back with
--   respect to neovim's interpretation.
--   
--   The <a>NFData</a> 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.
class NFData o => NvimObject o
toObject :: NvimObject o => o -> Object
fromObjectUnsafe :: NvimObject o => Object -> o
fromObject :: NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject' :: (NvimObject o, (MonadIO io)) => Object -> io o

-- | 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.
type Dictionary = Map ByteString Object

-- | Convenient operator to create a list of <a>Object</a> from normal
--   values. <tt> values +: of :+ different :+ types :+ can +: be +:
--   combined +: this +: way +: [] </tt>
(+:) :: (NvimObject o) => o -> [Object] -> [Object]
infixr 5 +:

-- | Representable types of kind *. This class is derivable in GHC with the
--   DeriveGeneric flag on.
class Generic a

-- | Convert a <a>Doc</a>-ument to a messagepack <a>Object</a>. This is
--   more a convenience method to transport error message from and to
--   neovim. It generally does not hold that 'docToObject . docFromObject'
--   = <a>id</a>.
docToObject :: Doc AnsiStyle -> Object

-- | See <a>docToObject</a>.
docFromObject :: Object -> Either (Doc AnsiStyle) (Doc AnsiStyle)
docToText :: Doc AnsiStyle -> Text

-- | The abstract data type <tt><a>Doc</a> ann</tt> represents pretty
--   documents that have been annotated with data of type <tt>ann</tt>.
--   
--   More specifically, a value of type <tt><a>Doc</a></tt> represents a
--   non-empty set of possible layouts of a document. The layout functions
--   select one of these possibilities, taking into account things like the
--   width of the output document.
--   
--   The annotation is an arbitrary piece of data associated with (part of)
--   a document. Annotations may be used by the rendering backends in order
--   to display output differently, such as
--   
--   <ul>
--   <li>color information (e.g. when rendering to the terminal)</li>
--   <li>mouseover text (e.g. when rendering to rich HTML)</li>
--   <li>whether to show something or not (to allow simple or detailed
--   versions)</li>
--   </ul>
--   
--   The simplest way to display a <a>Doc</a> is via the <a>Show</a> class.
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn (show (vsep ["hello", "world"]))
--   hello
--   world
--   </pre>
data Doc ann :: * -> *

-- | Render the annotated document in a certain style. Styles not set in
--   the annotation will use the style of the surrounding document, or the
--   terminal’s default if none has been set yet.
--   
--   <pre>
--   style = <a>color</a> <a>Green</a> <a>&lt;&gt;</a> <a>bold</a>
--   styledDoc = <a>annotate</a> style "hello world"
--   </pre>
data AnsiStyle :: *

-- | Overloaded conversion to <a>Doc</a>.
--   
--   Laws:
--   
--   <ol>
--   <li>output should be pretty. :-)</li>
--   </ol>
class Pretty a

-- | <pre>
--   &gt;&gt;&gt; pretty 1 &lt;+&gt; pretty "hello" &lt;+&gt; pretty 1.234
--   1 hello 1.234
--   </pre>
pretty :: Pretty a => a -> Doc ann

-- | <tt><a>prettyList</a></tt> is only used to define the <tt>instance
--   <a>Pretty</a> a =&gt; <a>Pretty</a> [a]</tt>. In normal circumstances
--   only the <tt><a>pretty</a></tt> function is used.
--   
--   <pre>
--   &gt;&gt;&gt; prettyList [1, 23, 456]
--   [1, 23, 456]
--   </pre>
prettyList :: Pretty a => [a] -> Doc ann

-- | <tt>(x <a>&lt;+&gt;</a> y)</tt> concatenates document <tt>x</tt> and
--   <tt>y</tt> with a <tt><tt>space</tt></tt> in between.
--   
--   <pre>
--   &gt;&gt;&gt; "hello" &lt;+&gt; "world"
--   hello world
--   </pre>
--   
--   <pre>
--   x <a>&lt;+&gt;</a> y = x <a>&lt;&gt;</a> <tt>space</tt> <a>&lt;&gt;</a> y
--   </pre>
(<+>) :: () => Doc ann -> Doc ann -> Doc ann
instance Neovim.Classes.NvimObject ()
instance Neovim.Classes.NvimObject GHC.Types.Bool
instance Neovim.Classes.NvimObject GHC.Types.Double
instance Neovim.Classes.NvimObject GHC.Integer.Type.Integer
instance Neovim.Classes.NvimObject GHC.Int.Int64
instance Neovim.Classes.NvimObject GHC.Int.Int32
instance Neovim.Classes.NvimObject GHC.Int.Int16
instance Neovim.Classes.NvimObject GHC.Int.Int8
instance Neovim.Classes.NvimObject GHC.Types.Word
instance Neovim.Classes.NvimObject GHC.Word.Word64
instance Neovim.Classes.NvimObject GHC.Word.Word32
instance Neovim.Classes.NvimObject GHC.Word.Word16
instance Neovim.Classes.NvimObject GHC.Word.Word8
instance Neovim.Classes.NvimObject GHC.Types.Int
instance Neovim.Classes.NvimObject [GHC.Types.Char]
instance Neovim.Classes.NvimObject o => Neovim.Classes.NvimObject [o]
instance Neovim.Classes.NvimObject o => Neovim.Classes.NvimObject (GHC.Base.Maybe o)
instance (Neovim.Classes.NvimObject l, Neovim.Classes.NvimObject r) => Neovim.Classes.NvimObject (Data.Either.Either l r)
instance (GHC.Classes.Ord key, Neovim.Classes.NvimObject key, Neovim.Classes.NvimObject val) => Neovim.Classes.NvimObject (Data.Map.Internal.Map key val)
instance Neovim.Classes.NvimObject Data.Text.Internal.Text
instance Neovim.Classes.NvimObject Data.ByteString.Internal.ByteString
instance Neovim.Classes.NvimObject Data.MessagePack.Object
instance (Neovim.Classes.NvimObject o1, Neovim.Classes.NvimObject o2) => Neovim.Classes.NvimObject (o1, o2)
instance (Neovim.Classes.NvimObject o1, Neovim.Classes.NvimObject o2, Neovim.Classes.NvimObject o3) => Neovim.Classes.NvimObject (o1, o2, o3)
instance (Neovim.Classes.NvimObject o1, Neovim.Classes.NvimObject o2, Neovim.Classes.NvimObject o3, Neovim.Classes.NvimObject o4) => Neovim.Classes.NvimObject (o1, o2, o3, o4)
instance (Neovim.Classes.NvimObject o1, Neovim.Classes.NvimObject o2, Neovim.Classes.NvimObject o3, Neovim.Classes.NvimObject o4, Neovim.Classes.NvimObject o5) => Neovim.Classes.NvimObject (o1, o2, o3, o4, o5)
instance (Neovim.Classes.NvimObject o1, Neovim.Classes.NvimObject o2, Neovim.Classes.NvimObject o3, Neovim.Classes.NvimObject o4, Neovim.Classes.NvimObject o5, Neovim.Classes.NvimObject o6) => Neovim.Classes.NvimObject (o1, o2, o3, o4, o5, o6)
instance (Neovim.Classes.NvimObject o1, Neovim.Classes.NvimObject o2, Neovim.Classes.NvimObject o3, Neovim.Classes.NvimObject o4, Neovim.Classes.NvimObject o5, Neovim.Classes.NvimObject o6, Neovim.Classes.NvimObject o7) => Neovim.Classes.NvimObject (o1, o2, o3, o4, o5, o6, o7)
instance (Neovim.Classes.NvimObject o1, Neovim.Classes.NvimObject o2, Neovim.Classes.NvimObject o3, Neovim.Classes.NvimObject o4, Neovim.Classes.NvimObject o5, Neovim.Classes.NvimObject o6, Neovim.Classes.NvimObject o7, Neovim.Classes.NvimObject o8) => Neovim.Classes.NvimObject (o1, o2, o3, o4, o5, o6, o7, o8)
instance (Neovim.Classes.NvimObject o1, Neovim.Classes.NvimObject o2, Neovim.Classes.NvimObject o3, Neovim.Classes.NvimObject o4, Neovim.Classes.NvimObject o5, Neovim.Classes.NvimObject o6, Neovim.Classes.NvimObject o7, Neovim.Classes.NvimObject o8, Neovim.Classes.NvimObject o9) => Neovim.Classes.NvimObject (o1, o2, o3, o4, o5, o6, o7, o8, o9)


module Neovim.API.Parser

-- | This data type represents the top-level structure of the <tt>nvim
--   --api-info</tt> output.
data NeovimAPI
NeovimAPI :: [(String, Int64)] -> [(String, Int64)] -> [NeovimFunction] -> NeovimAPI

-- | The error types are defined by a name and an identifier.
[errorTypes] :: NeovimAPI -> [(String, Int64)]

-- | Extension types defined by neovim.
[customTypes] :: NeovimAPI -> [(String, Int64)]

-- | The remotely executable functions provided by the neovim api.
[functions] :: NeovimAPI -> [NeovimFunction]

-- | This data type contains simple information about a function as
--   received throudh the <tt>nvim --api-info</tt> command.
data NeovimFunction
NeovimFunction :: String -> [(NeovimType, String)] -> Bool -> Bool -> NeovimType -> NeovimFunction

-- | function name
[name] :: NeovimFunction -> String

-- | A list of type name and variable name.
[parameters] :: NeovimFunction -> [(NeovimType, String)]

-- | Indicator whether the function can fail/throws exceptions.
[canFail] :: NeovimFunction -> Bool

-- | Indicator whether the this function is asynchronous.
[async] :: NeovimFunction -> Bool

-- | Functions return type.
[returnType] :: NeovimFunction -> NeovimType
data NeovimType
SimpleType :: String -> NeovimType
NestedType :: NeovimType -> (Maybe Int) -> NeovimType
Void :: NeovimType

-- | Run <tt>nvim --api-info</tt> and parse its output.
parseAPI :: IO (Either (Doc AnsiStyle) NeovimAPI)
instance GHC.Show.Show Neovim.API.Parser.NeovimAPI
instance GHC.Show.Show Neovim.API.Parser.NeovimFunction
instance GHC.Classes.Eq Neovim.API.Parser.NeovimType
instance GHC.Show.Show Neovim.API.Parser.NeovimType


module Neovim.Log

-- | Disable logging to stderr.
disableLogger :: IO a -> IO a

-- | 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.
--   
--   <pre>
--   main = <a>withLogger</a> "/home/dude/nvim.log" <tt>Debug</tt> $ do
--       <a>putStrLn</a> "Hello, World!"
--   </pre>
withLogger :: FilePath -> Priority -> IO a -> IO a


module Neovim.Plugin.Classes

-- | Functionality 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 <a>def</a> can be used as an
--   argument.
data FunctionalityDescription

-- | Exported function. Callable via <tt>call name(arg1,arg2)</tt>.
--   
--   <ul>
--   <li>Name of the function (must start with an uppercase letter)</li>
--   <li>Option to indicate how neovim should behave when calling this
--   function</li>
--   </ul>
Function :: FunctionName -> Synchronous -> FunctionalityDescription

-- | Exported Command. Callable via <tt>:Name arg1 arg2</tt>.
--   
--   <ul>
--   <li>Name of the command (must start with an uppercase letter)</li>
--   <li>Options to configure neovim's behavior for calling the
--   command</li>
--   </ul>
Command :: FunctionName -> CommandOptions -> FunctionalityDescription

-- | Exported 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.
--   
--   <ul>
--   <li>Type of the autocmd (e.g. "BufWritePost")</li>
--   <li>Name for the function to call</li>
--   <li>Options for the autocmd (use <a>def</a> here if you don't want to
--   change anything)</li>
--   </ul>
Autocmd :: ByteString -> FunctionName -> AutocmdOptions -> FunctionalityDescription

-- | Essentially just a string.
newtype FunctionName
F :: ByteString -> FunctionName

-- | This option detemines how neovim should behave when calling some
--   functionality on a remote host.
data Synchronous

-- | 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.
Async :: Synchronous

-- | 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.
Sync :: Synchronous

-- | Options for commands.
--   
--   Some command can also be described by using the OverloadedString
--   extensions. This means that you can write a literal <a>String</a>
--   inside your source file in place for a <a>CommandOption</a> value. See
--   the documentation for each value on how these strings should look like
--   (Both versions are compile time checked.)
data CommandOption

-- | Stringliteral "sync" or "async"
CmdSync :: Synchronous -> CommandOption

-- | Register passed to the command.
--   
--   Stringliteral: <tt>"\""</tt>
CmdRegister :: CommandOption

-- | Command takes a specific amount of arguments
--   
--   Automatically set via template haskell functions. You really shouldn't
--   use this option yourself unless you have to.
CmdNargs :: String -> CommandOption

-- | Determines how neovim passes the range.
--   
--   Stringliterals: "%" for <a>WholeFile</a>, "," for line and ",123" for
--   123 lines.
CmdRange :: RangeSpecification -> CommandOption

-- | Command handles a count. The argument defines the default count.
--   
--   Stringliteral: string of numbers (e.g. "132")
CmdCount :: Word -> CommandOption

-- | Command handles a bang
--   
--   Stringliteral: "!"
CmdBang :: CommandOption

-- | Newtype wrapper for a list of <a>CommandOption</a>. Any properly
--   constructed object of this type is sorted and only contains zero or
--   one object for each possible option.
data CommandOptions

-- | Specification of a range that acommand can operate on.
data RangeSpecification

-- | The line the cursor is at when the command is invoked.
CurrentLine :: RangeSpecification

-- | Let the command operate on every line of the file.
WholeFile :: RangeSpecification

-- | Let the command operate on each line in the given range.
RangeCount :: Int -> RangeSpecification

-- | You 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.
data CommandArguments
CommandArguments :: Maybe Bool -> Maybe (Int, Int) -> Maybe Int -> Maybe String -> CommandArguments

-- | <a>Nothing</a> means that the function was not defined to handle a
--   bang, otherwise it means that the bang was passed (<tt><a>Just</a>
--   <a>True</a></tt>) or that it was not passed when called
--   (<tt><a>Just</a> <a>False</a></tt>).
[bang] :: CommandArguments -> Maybe Bool

-- | Range passed from neovim. Only set if <a>CmdRange</a> was used in the
--   export declaration of the command.
--   
--   Example:
--   
--   <ul>
--   <li><pre>Just (1,12)</pre></li>
--   </ul>
[range] :: CommandArguments -> Maybe (Int, Int)

-- | Count passed by neovim. Only set if <a>CmdCount</a> was used in the
--   export declaration of the command.
[count] :: CommandArguments -> Maybe Int

-- | Register that the command can/should/must use.
[register] :: CommandArguments -> Maybe String
getCommandOptions :: CommandOptions -> [CommandOption]

-- | Smart constructor for <a>CommandOptions</a>. 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.
mkCommandOptions :: [CommandOption] -> CommandOptions

-- | Options that can be used to register an autocmd. See <tt>:h
--   :autocmd</tt> or any referenced neovim help-page from the fields of
--   this data type.
data AutocmdOptions
AutocmdOptions :: String -> Bool -> Maybe String -> AutocmdOptions

-- | Pattern to match on. (default: "*")
[acmdPattern] :: AutocmdOptions -> String

-- | Nested autocmd. (default: False)
--   
--   See <tt>:h autocmd-nested</tt>
[acmdNested] :: AutocmdOptions -> Bool

-- | Group in which the autocmd should be registered.
[acmdGroup] :: AutocmdOptions -> Maybe String

-- | Conveniennce class to extract a name from some value.
class HasFunctionName a
name :: HasFunctionName a => a -> FunctionName
instance GHC.Generics.Generic Neovim.Plugin.Classes.FunctionalityDescription
instance GHC.Classes.Ord Neovim.Plugin.Classes.FunctionalityDescription
instance GHC.Classes.Eq Neovim.Plugin.Classes.FunctionalityDescription
instance GHC.Read.Read Neovim.Plugin.Classes.FunctionalityDescription
instance GHC.Show.Show Neovim.Plugin.Classes.FunctionalityDescription
instance GHC.Generics.Generic Neovim.Plugin.Classes.AutocmdOptions
instance GHC.Classes.Ord Neovim.Plugin.Classes.AutocmdOptions
instance GHC.Classes.Eq Neovim.Plugin.Classes.AutocmdOptions
instance GHC.Read.Read Neovim.Plugin.Classes.AutocmdOptions
instance GHC.Show.Show Neovim.Plugin.Classes.AutocmdOptions
instance GHC.Generics.Generic Neovim.Plugin.Classes.CommandArguments
instance GHC.Read.Read Neovim.Plugin.Classes.CommandArguments
instance GHC.Show.Show Neovim.Plugin.Classes.CommandArguments
instance GHC.Classes.Ord Neovim.Plugin.Classes.CommandArguments
instance GHC.Classes.Eq Neovim.Plugin.Classes.CommandArguments
instance GHC.Generics.Generic Neovim.Plugin.Classes.CommandOptions
instance GHC.Read.Read Neovim.Plugin.Classes.CommandOptions
instance GHC.Show.Show Neovim.Plugin.Classes.CommandOptions
instance GHC.Classes.Ord Neovim.Plugin.Classes.CommandOptions
instance GHC.Classes.Eq Neovim.Plugin.Classes.CommandOptions
instance GHC.Generics.Generic Neovim.Plugin.Classes.CommandOption
instance GHC.Read.Read Neovim.Plugin.Classes.CommandOption
instance GHC.Show.Show Neovim.Plugin.Classes.CommandOption
instance GHC.Classes.Ord Neovim.Plugin.Classes.CommandOption
instance GHC.Classes.Eq Neovim.Plugin.Classes.CommandOption
instance GHC.Generics.Generic Neovim.Plugin.Classes.RangeSpecification
instance GHC.Read.Read Neovim.Plugin.Classes.RangeSpecification
instance GHC.Show.Show Neovim.Plugin.Classes.RangeSpecification
instance GHC.Classes.Ord Neovim.Plugin.Classes.RangeSpecification
instance GHC.Classes.Eq Neovim.Plugin.Classes.RangeSpecification
instance GHC.Generics.Generic Neovim.Plugin.Classes.Synchronous
instance GHC.Enum.Enum Neovim.Plugin.Classes.Synchronous
instance GHC.Classes.Ord Neovim.Plugin.Classes.Synchronous
instance GHC.Classes.Eq Neovim.Plugin.Classes.Synchronous
instance GHC.Read.Read Neovim.Plugin.Classes.Synchronous
instance GHC.Show.Show Neovim.Plugin.Classes.Synchronous
instance GHC.Generics.Generic Neovim.Plugin.Classes.FunctionName
instance GHC.Read.Read Neovim.Plugin.Classes.FunctionName
instance GHC.Show.Show Neovim.Plugin.Classes.FunctionName
instance GHC.Classes.Ord Neovim.Plugin.Classes.FunctionName
instance GHC.Classes.Eq Neovim.Plugin.Classes.FunctionName
instance Neovim.Plugin.Classes.HasFunctionName Neovim.Plugin.Classes.FunctionalityDescription
instance Control.DeepSeq.NFData Neovim.Plugin.Classes.FunctionalityDescription
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.Classes.FunctionalityDescription
instance Control.DeepSeq.NFData Neovim.Plugin.Classes.AutocmdOptions
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.Classes.AutocmdOptions
instance Data.Default.Class.Default Neovim.Plugin.Classes.AutocmdOptions
instance Neovim.Classes.NvimObject Neovim.Plugin.Classes.AutocmdOptions
instance Control.DeepSeq.NFData Neovim.Plugin.Classes.CommandArguments
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.Classes.CommandArguments
instance Data.Default.Class.Default Neovim.Plugin.Classes.CommandArguments
instance Neovim.Classes.NvimObject Neovim.Plugin.Classes.CommandArguments
instance Control.DeepSeq.NFData Neovim.Plugin.Classes.CommandOptions
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.Classes.CommandOptions
instance Neovim.Classes.NvimObject Neovim.Plugin.Classes.CommandOptions
instance Control.DeepSeq.NFData Neovim.Plugin.Classes.CommandOption
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.Classes.CommandOption
instance Data.String.IsString Neovim.Plugin.Classes.CommandOption
instance Control.DeepSeq.NFData Neovim.Plugin.Classes.RangeSpecification
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.Classes.RangeSpecification
instance Neovim.Classes.NvimObject Neovim.Plugin.Classes.RangeSpecification
instance Control.DeepSeq.NFData Neovim.Plugin.Classes.Synchronous
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.Classes.Synchronous
instance Data.String.IsString Neovim.Plugin.Classes.Synchronous
instance Neovim.Classes.NvimObject Neovim.Plugin.Classes.Synchronous
instance Control.DeepSeq.NFData Neovim.Plugin.Classes.FunctionName
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.Classes.FunctionName


module Neovim.Plugin.IPC.Classes

-- | Taken from xmonad and based on ideas in /An Extensible
--   Dynamically-Typed Hierarchy of Exceptions/, Simon Marlow, 2006.
--   
--   User-extensible messages must be put into a value of this type, so
--   that it can be sent to other plugins.
data SomeMessage
SomeMessage :: msg -> SomeMessage

-- | This class allows type safe casting of <a>SomeMessage</a> to an actual
--   message. The cast is successful if the type you're expecting matches
--   the type in the <a>SomeMessage</a> 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
--   <i>nvim-hs</i>.
class Typeable message => Message message

-- | Try to convert a given message to a value of the message type we are
--   interested in. Will evaluate to <a>Nothing</a> for any other type.
fromMessage :: Message message => SomeMessage -> Maybe message

-- | Haskell representation of supported Remote Procedure Call messages.
data FunctionCall

-- | Method name, parameters, callback, timestamp
FunctionCall :: FunctionName -> [Object] -> (TMVar (Either Object Object)) -> UTCTime -> FunctionCall

-- | 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.
data Request
Request :: FunctionName -> !Int64 -> [Object] -> Request

-- | Name of the function to call.
[reqMethod] :: Request -> FunctionName

-- | Identifier to map the result to a function call invocation.
[reqId] :: Request -> !Int64

-- | Arguments for the function.
[reqArgs] :: Request -> [Object]

-- | A notification is similar to a <a>Request</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.
data Notification
Notification :: FunctionName -> [Object] -> Notification

-- | Name of the function to call.
[notMethod] :: Notification -> FunctionName

-- | Arguments for the function.
[notArgs] :: Notification -> [Object]

-- | This is the simplest representation of UTC. It consists of the day
--   number, and a time offset from midnight. Note that if a day has a leap
--   second added to it, it will have 86401 seconds.
data UTCTime :: *

-- | Get the current <a>UTCTime</a> from the system clock.
getCurrentTime :: IO UTCTime
instance GHC.Generics.Generic Neovim.Plugin.IPC.Classes.Notification
instance GHC.Show.Show Neovim.Plugin.IPC.Classes.Notification
instance GHC.Classes.Ord Neovim.Plugin.IPC.Classes.Notification
instance GHC.Classes.Eq Neovim.Plugin.IPC.Classes.Notification
instance GHC.Generics.Generic Neovim.Plugin.IPC.Classes.Request
instance GHC.Show.Show Neovim.Plugin.IPC.Classes.Request
instance GHC.Classes.Ord Neovim.Plugin.IPC.Classes.Request
instance GHC.Classes.Eq Neovim.Plugin.IPC.Classes.Request
instance Control.DeepSeq.NFData Neovim.Plugin.IPC.Classes.Notification
instance Neovim.Plugin.IPC.Classes.Message Neovim.Plugin.IPC.Classes.Notification
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.IPC.Classes.Notification
instance Control.DeepSeq.NFData Neovim.Plugin.IPC.Classes.Request
instance Neovim.Plugin.IPC.Classes.Message Neovim.Plugin.IPC.Classes.Request
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.IPC.Classes.Request
instance Neovim.Plugin.IPC.Classes.Message Neovim.Plugin.IPC.Classes.FunctionCall
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Plugin.IPC.Classes.FunctionCall


-- | This module reexports publicly available means to communicate between
--   different plugins (or more generally threads running in the same
--   plugin provider).
module Neovim.Plugin.IPC

-- | Taken from xmonad and based on ideas in /An Extensible
--   Dynamically-Typed Hierarchy of Exceptions/, Simon Marlow, 2006.
--   
--   User-extensible messages must be put into a value of this type, so
--   that it can be sent to other plugins.
data SomeMessage
SomeMessage :: msg -> SomeMessage

-- | Try to convert a given message to a value of the message type we are
--   interested in. Will evaluate to <a>Nothing</a> for any other type.
fromMessage :: Message message => SomeMessage -> Maybe message


-- | To shorten function and data type names, import this qualfied as
--   <tt>Internal</tt>.
module Neovim.Context.Internal

-- | This 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 <a>IO</a> in general haskell programs.
newtype Neovim env a
Neovim :: ResourceT (ReaderT (Config env) IO) a -> Neovim env a
[unNeovim] :: Neovim env a -> ResourceT (ReaderT (Config env) IO) a

-- | User facing instance declaration for the reader state.

-- | Same as <a>ask</a> for the <tt>InternalConfig</tt>.
ask' :: Neovim env (Config env)

-- | Same as <a>asks</a> for the <tt>InternalConfig</tt>.
asks' :: (Config env -> a) -> Neovim env a
exceptionHandlers :: [Handler IO (Either (Doc ann) a)]

-- | Initialize a <a>Neovim</a> context by supplying an
--   <tt>InternalEnvironment</tt>.
runNeovim :: NFData a => Config env -> Neovim env a -> IO (Either (Doc AnsiStyle) a)
runNeovimInternal :: (a -> IO a) -> Config env -> Neovim env a -> IO (Either (Doc AnsiStyle) a)

-- | Create a new unique function name. To prevent possible name clashes,
--   digits are stripped from the given suffix.
newUniqueFunctionName :: Neovim env FunctionName

-- | This data type is used to dispatch a remote function call to the
--   appopriate recipient.
newtype FunctionType

-- | <a>Stateful</a> functions are handled within a special thread, the
--   <a>TQueue</a> is the communication endpoint for the arguments we have
--   to pass.
Stateful :: (TQueue SomeMessage) -> FunctionType

-- | Type of the values stored in the function map.
type FunctionMapEntry = (FunctionalityDescription, FunctionType)

-- | 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 <a>Object</a> values and returns a result in the
--   <a>Neovim</a> context. The second case is calling a function that has
--   a persistent state. This is mediated to a thread that reads from a
--   <a>TQueue</a>. (NB: persistent currently means, that state is stored
--   for as long as the plugin provider is running and not restarted.)
type FunctionMap = Map FunctionName FunctionMapEntry

-- | Create a new function map from the given list of
--   <a>FunctionMapEntry</a> values.
mkFunctionMap :: [FunctionMapEntry] -> FunctionMap

-- | 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.
--   
--   Note that you most probably do not want to change the fields prefixed
--   with an underscore.
data Config env
Config :: TQueue SomeMessage -> MVar StateTransition -> TMVar (Either String Int) -> TVar Integer -> TMVar FunctionMap -> Maybe (PluginSettings env) -> env -> Config env

-- | A queue of messages that the event handler will propagate to
--   appropriate threads and handlers.
[eventQueue] :: Config env -> TQueue SomeMessage

-- | The main thread will wait for this <a>MVar</a> to be filled with a
--   value and then perform an action appropriate for the value of type
--   <a>StateTransition</a>.
[transitionTo] :: Config env -> MVar StateTransition

-- | Since nvim-hs must have its <a>Neovim.RPC.SocketReader</a> and
--   <a>Neovim.RPC.EventHandler</a> running to determine the actual channel
--   id (i.e. the <a>Int</a> value here) this field can only be set
--   properly later. Hence, the value of this field is put in an
--   <a>TMVar</a>. Name that is used to identify this provider. Assigning
--   such a name is done in the neovim config (e.g. ~/.nvim/nvimrc).
[providerName] :: Config env -> TMVar (Either String Int)

-- | This <a>TVar</a> is used to generate uniqe function names on the side
--   of <i>nvim-hs</i>. This is useful if you don't want to overwrite
--   existing functions or if you create autocmd functions.
[uniqueCounter] :: Config env -> TVar Integer

-- | This map is used to dispatch received messagepack function calls to
--   it's appropriate targets.
[globalFunctionMap] :: Config env -> TMVar FunctionMap

-- | In a registered functionality this field contains a function (and
--   possibly some context dependent values) to register new functionality.
[pluginSettings] :: Config env -> Maybe (PluginSettings env)

-- | Plugin author supplyable custom configuration. Queried on the
--   user-facing side with <a>ask</a> or <a>asks</a>.
[customConfig] :: Config env -> env

-- | Convenient helper to create a new config for the given state and
--   read-only config.
--   
--   Sets the <a>pluginSettings</a> field to <a>Nothing</a>.
retypeConfig :: env -> Config anotherEnv -> Config env

-- | 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.
data PluginSettings env
[StatefulSettings] :: (FunctionalityDescription -> ([Object] -> Neovim env Object) -> TQueue SomeMessage -> TVar (Map FunctionName ([Object] -> Neovim env Object)) -> Neovim env (Maybe FunctionMapEntry)) -> TQueue SomeMessage -> TVar (Map FunctionName ([Object] -> Neovim env Object)) -> PluginSettings env

-- | Create a new <tt>InternalConfig</tt> object by providing the minimal
--   amount of necessary information.
--   
--   This function should only be called once per <i>nvim-hs</i> session
--   since the arguments are shared across processes.
newConfig :: IO (Maybe String) -> IO env -> IO (Config env)

-- | The state that the plugin provider wants to transition to.
data StateTransition

-- | Quit the plugin provider.
Quit :: StateTransition

-- | Restart the plugin provider.
Restart :: StateTransition

-- | The plugin provider failed to start or some other error occured.
Failure :: (Doc AnsiStyle) -> StateTransition

-- | The plugin provider started successfully.
InitSuccess :: StateTransition
instance Control.Monad.Catch.MonadThrow (Neovim.Context.Internal.Neovim env)
instance Control.Monad.IO.Class.MonadIO (Neovim.Context.Internal.Neovim env)
instance GHC.Base.Monad (Neovim.Context.Internal.Neovim env)
instance GHC.Base.Applicative (Neovim.Context.Internal.Neovim env)
instance GHC.Base.Functor (Neovim.Context.Internal.Neovim env)
instance GHC.Show.Show Neovim.Context.Internal.StateTransition
instance Control.Monad.Reader.Class.MonadReader env (Neovim.Context.Internal.Neovim env)
instance Control.Monad.Trans.Resource.Internal.MonadResource (Neovim.Context.Internal.Neovim env)
instance Control.Monad.IO.Unlift.MonadUnliftIO (Neovim.Context.Internal.Neovim env)
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.Context.Internal.FunctionType


module Neovim.Context

-- | Create a new unique function name. To prevent possible name clashes,
--   digits are stripped from the given suffix.
newUniqueFunctionName :: Neovim env FunctionName

-- | This 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 <a>IO</a> in general haskell programs.
data Neovim env a

-- | Exceptions specific to <i>nvim-hs</i>.
data NeovimException

-- | Simply error message that is passed to neovim. It should currently
--   only contain one line of text.
ErrorMessage :: (Doc AnsiStyle) -> NeovimException

-- | Error that can be returned by a remote API call. A call of
--   <tt>fromObject</tt> on this value could be converted to a value of
--   <tt>NeovimExceptionGen</tt>.
ErrorResult :: Object -> NeovimException
exceptionToDoc :: NeovimException -> Doc AnsiStyle

-- | 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 <a>Object</a> values and returns a result in the
--   <a>Neovim</a> context. The second case is calling a function that has
--   a persistent state. This is mediated to a thread that reads from a
--   <a>TQueue</a>. (NB: persistent currently means, that state is stored
--   for as long as the plugin provider is running and not restarted.)
type FunctionMap = Map FunctionName FunctionMapEntry

-- | Type of the values stored in the function map.
type FunctionMapEntry = (FunctionalityDescription, FunctionType)

-- | Create a new function map from the given list of
--   <a>FunctionMapEntry</a> values.
mkFunctionMap :: [FunctionMapEntry] -> FunctionMap

-- | Initialize a <a>Neovim</a> context by supplying an
--   <tt>InternalEnvironment</tt>.
runNeovim :: NFData a => Config env -> Neovim env a -> IO (Either (Doc AnsiStyle) a)

-- | <tt><a>throw</a></tt> specialized to a <a>Pretty</a> value.
err :: Doc AnsiStyle -> Neovim env a
errOnInvalidResult :: (NvimObject o) => Neovim env (Either NeovimException Object) -> Neovim env o

-- | Initiate a restart of the plugin provider.
restart :: Neovim env ()

-- | Initiate the termination of the plugin provider.
quit :: Neovim env ()

-- | Retrieves the monad environment.
ask :: MonadReader r m => m r

-- | Retrieves a function of the current environment.
asks :: MonadReader r m => (r -> a) -> m a

-- | Return the state from the internals of the monad.
get :: MonadState s m => m s

-- | Gets specific component of the state, using a projection function
--   supplied.
gets :: MonadState s m => (s -> a) -> m a

-- | Replace the state inside the monad.
put :: MonadState s m => s -> m ()

-- | Monadic state transformer.
--   
--   Maps an old state to a new state inside a state monad. The old state
--   is thrown away.
--   
--   <pre>
--   Main&gt; :t modify ((+1) :: Int -&gt; Int)
--   modify (...) :: (MonadState Int a) =&gt; a ()
--   </pre>
--   
--   This says that <tt>modify (+1)</tt> acts over any Monad that is a
--   member of the <tt>MonadState</tt> class, with an <tt>Int</tt> state.
modify :: MonadState s m => (s -> s) -> m ()

-- | The abstract data type <tt><a>Doc</a> ann</tt> represents pretty
--   documents that have been annotated with data of type <tt>ann</tt>.
--   
--   More specifically, a value of type <tt><a>Doc</a></tt> represents a
--   non-empty set of possible layouts of a document. The layout functions
--   select one of these possibilities, taking into account things like the
--   width of the output document.
--   
--   The annotation is an arbitrary piece of data associated with (part of)
--   a document. Annotations may be used by the rendering backends in order
--   to display output differently, such as
--   
--   <ul>
--   <li>color information (e.g. when rendering to the terminal)</li>
--   <li>mouseover text (e.g. when rendering to rich HTML)</li>
--   <li>whether to show something or not (to allow simple or detailed
--   versions)</li>
--   </ul>
--   
--   The simplest way to display a <a>Doc</a> is via the <a>Show</a> class.
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn (show (vsep ["hello", "world"]))
--   hello
--   world
--   </pre>
data Doc ann :: * -> *

-- | Render the annotated document in a certain style. Styles not set in
--   the annotation will use the style of the surrounding document, or the
--   terminal’s default if none has been set yet.
--   
--   <pre>
--   style = <a>color</a> <a>Green</a> <a>&lt;&gt;</a> <a>bold</a>
--   styledDoc = <a>annotate</a> style "hello world"
--   </pre>
data AnsiStyle :: *
docToText :: Doc AnsiStyle -> Text

-- | Is used within a monadic computation to begin exception processing.
throwError :: MonadError e m => forall a. () => e -> m a


module Neovim.Plugin.Internal

-- | This data type is used in the plugin registration to properly register
--   the functions.
newtype ExportedFunctionality env
EF :: (FunctionalityDescription, [Object] -> Neovim env Object) -> ExportedFunctionality env

-- | Extract the function of an <a>ExportedFunctionality</a>.
getFunction :: ExportedFunctionality env -> [Object] -> Neovim env Object

-- | Extract the description of an <a>ExportedFunctionality</a>.
getDescription :: ExportedFunctionality env -> FunctionalityDescription

-- | <a>Plugin</a> values are wraped inside this data type via
--   <a>wrapPlugin</a> so that we can put plugins in an ordinary list.
data NeovimPlugin
NeovimPlugin :: (Plugin env) -> NeovimPlugin

-- | This data type contains meta information for the plugin manager.
data Plugin env
Plugin :: env -> [ExportedFunctionality env] -> Plugin env
[environment] :: Plugin env -> env
[exports] :: Plugin env -> [ExportedFunctionality env]

-- | Wrap a <a>Plugin</a> in some nice blankets, so that we can put them in
--   a simple list.
wrapPlugin :: Applicative m => Plugin env -> m NeovimPlugin
instance Neovim.Plugin.Classes.HasFunctionName (Neovim.Plugin.Internal.ExportedFunctionality env)


-- | This plugin only exists due to cyclic dependencies.
module Neovim.Plugin.Startup

-- | This data type contains internal fields of <i>nvim-hs</i> that may be
--   useful for plugin authors. It is available via <tt>ask</tt> inside the
--   plugin startup code.
data StartupConfig cfg
StartupConfig :: Maybe (Params cfg) -> [(String, Maybe String)] -> StartupConfig cfg

-- | The configuration options for <a>Config.Dyre</a>. This is always set
--   if <i>nvim-hs</i> has been started via <a>Config.Dyre</a>. Be sure to
--   set up the <a>ghcEnvironmentVariables</a> correctly if you issue a
--   recompilation via the <a>Config.Dyre</a> API.
[dyreParams] :: StartupConfig cfg -> Maybe (Params cfg)

-- | The GHC environment variables with which <i>nvim-hs</i> has been
--   started. This are mainly of significance if you want to use the same
--   environment for compilation or a REPL that <i>nvim-hs</i> runs on.
--   
--   These variables have to be used if you want to invoke functionality of
--   <a>Config.Dyre</a> targeting <i>nvim-hs</i>.
[ghcEnvironmentVariables] :: StartupConfig cfg -> [(String, Maybe String)]


module Neovim.Config

-- | This 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 <a>Neovim</a> module should get you started.
data NeovimConfig
Config :: [Neovim (StartupConfig NeovimConfig) NeovimPlugin] -> Maybe (FilePath, Priority) -> Maybe String -> NeovimConfig

-- | The 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 <a>NeovimPlugin</a>.
[plugins] :: NeovimConfig -> [Neovim (StartupConfig NeovimConfig) NeovimPlugin]

-- | Set the general logging options.
[logOptions] :: NeovimConfig -> Maybe (FilePath, Priority)

-- | Internally used field. Changing this has no effect.
--   
--   Used by <tt>Dyre</tt> for storing compilation errors.
[errorMessage] :: NeovimConfig -> Maybe String


-- | Import this module qualified as <tt>MsgpackRPC</tt>
module Neovim.RPC.Classes

-- | See
--   <a>https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md</a>
--   for details about the msgpack rpc specification.
data Message

-- | Request in the sense of the msgpack rpc specification
--   
--   Parameters * Message identifier that has to be put in the response to
--   this request * Function name * Function arguments
Request :: Request -> Message

-- | Response in the sense of the msgpack rpc specifcation
--   
--   Parameters * Mesage identifier which matches a request * <a>Either</a>
--   an error <a>Object</a> or a result <a>Object</a>
Response :: !Int64 -> (Either Object Object) -> Message

-- | Notification in the sense of the msgpack rpc specification
Notification :: Notification -> Message
instance GHC.Generics.Generic Neovim.RPC.Classes.Message
instance GHC.Show.Show Neovim.RPC.Classes.Message
instance GHC.Classes.Ord Neovim.RPC.Classes.Message
instance GHC.Classes.Eq Neovim.RPC.Classes.Message
instance Control.DeepSeq.NFData Neovim.RPC.Classes.Message
instance Neovim.Plugin.IPC.Classes.Message Neovim.RPC.Classes.Message
instance Neovim.Classes.NvimObject Neovim.RPC.Classes.Message
instance Data.Text.Prettyprint.Doc.Internal.Pretty Neovim.RPC.Classes.Message


module Neovim.RPC.Common

-- | Things shared between the socket reader and the event handler.
data RPCConfig
RPCConfig :: TVar (Map Int64 (UTCTime, TMVar (Either Object Object))) -> TVar Int64 -> RPCConfig

-- | A map from message identifiers (as per RPC spec) to a tuple with a
--   timestamp and a <a>TMVar</a> that is used to communicate the result
--   back to the calling thread.
[recipients] :: RPCConfig -> TVar (Map Int64 (UTCTime, TMVar (Either Object Object)))

-- | Message identifier for the next message as per RPC spec.
[nextMessageId] :: RPCConfig -> TVar Int64

-- | Create a new basic configuration containing a communication channel
--   for remote procedure call events and an empty lookup table for
--   functions to mediate.
newRPCConfig :: (Applicative io, MonadIO io) => io RPCConfig

-- | Simple data type defining the kind of socket the socket reader should
--   use.
data SocketType

-- | Use the handle for receiving msgpack-rpc messages. This is suitable
--   for an embedded neovim which is used in test cases.
Stdout :: Handle -> SocketType

-- | Read the connection information from the environment variable
--   <tt>NVIM_LISTEN_ADDRESS</tt>.
Environment :: SocketType

-- | Use a unix socket.
UnixSocket :: FilePath -> SocketType

-- | Use an IP socket. First argument is the port and the second is the
--   host name.
TCP :: Int -> String -> SocketType

-- | Create a <a>Handle</a> from the given socket description.
--   
--   The handle is not automatically closed.
createHandle :: (Functor io, MonadIO io) => SocketType -> io Handle

-- | Close the handle and print a warning if the conduit chain has been
--   interrupted prematurely.
cleanUpHandle :: (MonadIO io) => Handle -> Bool -> io ()


module Neovim.RPC.FunctionCall

-- | Helper function that concurrently puts a <a>Message</a> in the event
--   queue and returns an <a>STM</a> action that returns the result.
acall :: (NvimObject result) => FunctionName -> [Object] -> Neovim env (STM (Either NeovimException result))

-- | Helper function similar to <a>acall</a> that throws a runtime
--   exception if the result is an error object.
acall' :: (NvimObject result) => FunctionName -> [Object] -> Neovim env (STM result)

-- | Call a neovim function synchronously. This function blocks until the
--   result is available.
scall :: (NvimObject result) => FunctionName -> [Object] -> Neovim env (Either NeovimException result)

-- | Helper function similar to <a>scall</a> that throws a runtime
--   exception if the result is an error object.
scall' :: NvimObject result => FunctionName -> [Object] -> Neovim env result

-- | Similar to <a>scall</a>, but throw a <a>NeovimException</a> instead of
--   returning it.
scallThrow :: (NvimObject result) => FunctionName -> [Object] -> Neovim env result

-- | Lifted variant of <a>atomically</a>.
atomically' :: (MonadIO io) => STM result -> io result

-- | Wait for the result of the STM action.
--   
--   This action possibly blocks as it is an alias for <tt> ioSTM -&gt;
--   ioSTM &gt;&gt;= liftIO . atomically</tt>.
wait :: Neovim env (STM result) -> Neovim env result

-- | Variant of <a>wait</a> that discards the result.
wait' :: Neovim env (STM result) -> Neovim env ()

-- | Wait for the result of the <a>STM</a> action and call <tt><a>err</a> .
--   (loc++) . show</tt> if the action returned an error.
waitErr :: String -> Neovim env (STM (Either NeovimException result)) -> Neovim env result

-- | <a>waitErr</a> that discards the result.
waitErr' :: String -> Neovim env (STM (Either NeovimException result)) -> Neovim env ()

-- | Send the result back to the neovim instance.
respond :: (NvimObject result) => Request -> Either String result -> Neovim env ()


module Neovim.RPC.EventHandler

-- | This function will establish a connection to the given socket and
--   write msgpack-rpc requests to it.
runEventHandler :: Handle -> Config RPCConfig -> IO ()
instance Control.Monad.Reader.Class.MonadReader (Neovim.Context.Internal.Config Neovim.RPC.Common.RPCConfig) Neovim.RPC.EventHandler.EventHandler
instance Control.Monad.IO.Class.MonadIO Neovim.RPC.EventHandler.EventHandler
instance GHC.Base.Monad Neovim.RPC.EventHandler.EventHandler
instance GHC.Base.Applicative Neovim.RPC.EventHandler.EventHandler
instance GHC.Base.Functor Neovim.RPC.EventHandler.EventHandler


module Neovim.API.TH

-- | Generate the API types and functions provided by <tt>nvim
--   --api-info</tt>.
--   
--   The provided map allows the use of different Haskell types for the
--   types defined in the API. The types must be an instance of
--   <a>NvimObject</a> and they must form an isomorphism with the sent
--   messages types. Currently, it provides a Convenient way to replace the
--   <i>String</i> type with <a>Text</a>, <a>ByteString</a> or
--   <a>String</a>.
generateAPI :: Map String (Q Type) -> Q [Dec]

-- | Define an exported function by providing a custom name and referencing
--   the function you want to export.
--   
--   Note that the name must start with an upper case letter.
--   
--   Example: <tt> $(function "MyExportedFunction" 'myDefinedFunction)
--   <tt>Sync</tt> </tt>
function :: String -> Name -> Q Exp

-- | Define an exported function. This function works exactly like
--   <a>function</a>, but it generates the exported name automatically by
--   converting the first letter to upper case.
function' :: Name -> Q Exp

-- | Similarly to <a>function</a>, this function is used to export a
--   command with a custom name.
--   
--   Note 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 <a>String</a>
--   with <a>ByteString</a> or <a>Text</a> if you wish:
--   
--   <ul>
--   <li><a>CommandArguments</a> -&gt; <a>Neovim</a> r st ()</li>
--   <li><a>CommandArguments</a> -&gt; <a>Maybe</a> <a>String</a> -&gt;
--   <a>Neovim</a> r st ()</li>
--   <li><a>CommandArguments</a> -&gt; <a>String</a> -&gt; <a>Neovim</a> r
--   st ()</li>
--   <li><a>CommandArguments</a> -&gt; [<a>String</a>] -&gt; <a>Neovim</a>
--   r st ()</li>
--   <li><a>CommandArguments</a> -&gt; <a>String</a> -&gt; [<a>String</a>]
--   -&gt; <a>Neovim</a> r st ()</li>
--   </ul>
--   
--   Example: <tt> $(command "RememberThePrime" 'someFunction)
--   [<a>CmdBang</a>] </tt>
--   
--   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.
command :: String -> Name -> Q Exp

-- | Define an exported command. This function works exactly like
--   <a>command</a>, but it generates the command name by converting the
--   first letter to upper case.
command' :: Name -> Q Exp
autocmd :: Name -> Q Exp

-- | Default type mappings for the requested API.
defaultAPITypeToHaskellTypeMap :: Map String (Q Type)
instance GHC.Read.Read Neovim.API.TH.ArgType
instance GHC.Show.Show Neovim.API.TH.ArgType
instance GHC.Classes.Ord Neovim.API.TH.ArgType
instance GHC.Classes.Eq Neovim.API.TH.ArgType


-- | Note that this module is completely generated. If you're reading this
--   on hackage, the actual functions of this module may be different from
--   what is available to you. All the functions in this module depend on
--   the neovim version that was used when this package was compiled.
module Neovim.API.String
data NeovimExceptionGen
NeovimException :: !ByteString -> NeovimExceptionGen
NeovimValidation :: !ByteString -> NeovimExceptionGen
data Buffer
Buffer :: !ByteString -> Buffer
data Tabpage
Tabpage :: !ByteString -> Tabpage
data Window
Window :: !ByteString -> Window
window_is_valid' :: Window -> forall env. Neovim env Bool
window_is_valid :: Window -> forall env. Neovim env (Either NeovimException Bool)
window_get_tabpage' :: Window -> forall env. Neovim env Tabpage
window_get_tabpage :: Window -> forall env. Neovim env (Either NeovimException Tabpage)
window_get_position' :: Window -> forall env. Neovim env (Int64, Int64)
window_get_position :: Window -> forall env. Neovim env (Either NeovimException (Int64, Int64))
window_set_option' :: Window -> String -> Object -> forall env. Neovim env ()
window_set_option :: Window -> String -> Object -> forall env. Neovim env (Either NeovimException ())
window_get_option' :: Window -> String -> forall env. Neovim env Object
window_get_option :: Window -> String -> forall env. Neovim env (Either NeovimException Object)
window_get_var' :: Window -> String -> forall env. Neovim env Object
window_get_var :: Window -> String -> forall env. Neovim env (Either NeovimException Object)
window_set_width' :: Window -> Int64 -> forall env. Neovim env ()
window_set_width :: Window -> Int64 -> forall env. Neovim env (Either NeovimException ())
window_get_width' :: Window -> forall env. Neovim env Int64
window_get_width :: Window -> forall env. Neovim env (Either NeovimException Int64)
window_set_height' :: Window -> Int64 -> forall env. Neovim env ()
window_set_height :: Window -> Int64 -> forall env. Neovim env (Either NeovimException ())
window_get_height' :: Window -> forall env. Neovim env Int64
window_get_height :: Window -> forall env. Neovim env (Either NeovimException Int64)
window_set_cursor' :: Window -> (Int64, Int64) -> forall env. Neovim env ()
window_set_cursor :: Window -> (Int64, Int64) -> forall env. Neovim env (Either NeovimException ())
window_get_cursor' :: Window -> forall env. Neovim env (Int64, Int64)
window_get_cursor :: Window -> forall env. Neovim env (Either NeovimException (Int64, Int64))
window_get_buffer' :: Window -> forall env. Neovim env Buffer
window_get_buffer :: Window -> forall env. Neovim env (Either NeovimException Buffer)
vim_get_api_info' :: forall env. Neovim env [Object]
vim_get_api_info :: forall env. Neovim env (Either NeovimException [Object])
vim_get_color_map' :: forall env. Neovim env (Map Object Object)
vim_get_color_map :: forall env. Neovim env (Either NeovimException (Map Object Object))
vim_name_to_color' :: String -> forall env. Neovim env Int64
vim_name_to_color :: String -> forall env. Neovim env (Either NeovimException Int64)
vim_unsubscribe' :: String -> forall env. Neovim env ()
vim_unsubscribe :: String -> forall env. Neovim env (Either NeovimException ())
vim_subscribe' :: String -> forall env. Neovim env ()
vim_subscribe :: String -> forall env. Neovim env (Either NeovimException ())
vim_set_current_tabpage' :: Tabpage -> forall env. Neovim env ()
vim_set_current_tabpage :: Tabpage -> forall env. Neovim env (Either NeovimException ())
vim_get_current_tabpage' :: forall env. Neovim env Tabpage
vim_get_current_tabpage :: forall env. Neovim env (Either NeovimException Tabpage)
vim_get_tabpages' :: forall env. Neovim env [Tabpage]
vim_get_tabpages :: forall env. Neovim env (Either NeovimException [Tabpage])
vim_set_current_window' :: Window -> forall env. Neovim env ()
vim_set_current_window :: Window -> forall env. Neovim env (Either NeovimException ())
vim_get_current_window' :: forall env. Neovim env Window
vim_get_current_window :: forall env. Neovim env (Either NeovimException Window)
vim_get_windows' :: forall env. Neovim env [Window]
vim_get_windows :: forall env. Neovim env (Either NeovimException [Window])
vim_set_current_buffer' :: Buffer -> forall env. Neovim env ()
vim_set_current_buffer :: Buffer -> forall env. Neovim env (Either NeovimException ())
vim_get_current_buffer' :: forall env. Neovim env Buffer
vim_get_current_buffer :: forall env. Neovim env (Either NeovimException Buffer)
vim_get_buffers' :: forall env. Neovim env [Buffer]
vim_get_buffers :: forall env. Neovim env (Either NeovimException [Buffer])
vim_report_error' :: String -> forall env. Neovim env ()
vim_report_error :: String -> forall env. Neovim env (Either NeovimException ())
vim_err_write' :: String -> forall env. Neovim env ()
vim_err_write :: String -> forall env. Neovim env (Either NeovimException ())
vim_out_write' :: String -> forall env. Neovim env ()
vim_out_write :: String -> forall env. Neovim env (Either NeovimException ())
vim_set_option' :: String -> Object -> forall env. Neovim env ()
vim_set_option :: String -> Object -> forall env. Neovim env (Either NeovimException ())
vim_get_option' :: String -> forall env. Neovim env Object
vim_get_option :: String -> forall env. Neovim env (Either NeovimException Object)
vim_get_vvar' :: String -> forall env. Neovim env Object
vim_get_vvar :: String -> forall env. Neovim env (Either NeovimException Object)
vim_get_var' :: String -> forall env. Neovim env Object
vim_get_var :: String -> forall env. Neovim env (Either NeovimException Object)
vim_del_current_line' :: forall env. Neovim env ()
vim_del_current_line :: forall env. Neovim env (Either NeovimException ())
vim_set_current_line' :: String -> forall env. Neovim env ()
vim_set_current_line :: String -> forall env. Neovim env (Either NeovimException ())
vim_get_current_line' :: forall env. Neovim env String
vim_get_current_line :: forall env. Neovim env (Either NeovimException String)
vim_change_directory' :: String -> forall env. Neovim env ()
vim_change_directory :: String -> forall env. Neovim env (Either NeovimException ())
vim_list_runtime_paths' :: forall env. Neovim env [String]
vim_list_runtime_paths :: forall env. Neovim env (Either NeovimException [String])
vim_strwidth' :: String -> forall env. Neovim env Int64
vim_strwidth :: String -> forall env. Neovim env (Either NeovimException Int64)
vim_call_function' :: String -> [Object] -> forall env. Neovim env Object
vim_call_function :: String -> [Object] -> forall env. Neovim env (Either NeovimException Object)
vim_eval' :: String -> forall env. Neovim env Object
vim_eval :: String -> forall env. Neovim env (Either NeovimException Object)
vim_command_output' :: String -> forall env. Neovim env String
vim_command_output :: String -> forall env. Neovim env (Either NeovimException String)
vim_replace_termcodes' :: String -> Bool -> Bool -> Bool -> forall env. Neovim env String
vim_replace_termcodes :: String -> Bool -> Bool -> Bool -> forall env. Neovim env (Either NeovimException String)
vim_input' :: String -> forall env. Neovim env Int64
vim_input :: String -> forall env. Neovim env (Either NeovimException Int64)
vim_feedkeys' :: String -> String -> Bool -> forall env. Neovim env ()
vim_feedkeys :: String -> String -> Bool -> forall env. Neovim env (Either NeovimException ())
vim_command' :: String -> forall env. Neovim env ()
vim_command :: String -> forall env. Neovim env (Either NeovimException ())
ui_try_resize' :: Int64 -> Int64 -> forall env. Neovim env Object
ui_try_resize :: Int64 -> Int64 -> forall env. Neovim env (Either NeovimException Object)
ui_detach' :: forall env. Neovim env ()
ui_detach :: forall env. Neovim env (Either NeovimException ())
tabpage_is_valid' :: Tabpage -> forall env. Neovim env Bool
tabpage_is_valid :: Tabpage -> forall env. Neovim env (Either NeovimException Bool)
tabpage_get_window' :: Tabpage -> forall env. Neovim env Window
tabpage_get_window :: Tabpage -> forall env. Neovim env (Either NeovimException Window)
tabpage_get_var' :: Tabpage -> String -> forall env. Neovim env Object
tabpage_get_var :: Tabpage -> String -> forall env. Neovim env (Either NeovimException Object)
tabpage_get_windows' :: Tabpage -> forall env. Neovim env [Window]
tabpage_get_windows :: Tabpage -> forall env. Neovim env (Either NeovimException [Window])
buffer_clear_highlight' :: Buffer -> Int64 -> Int64 -> Int64 -> forall env. Neovim env ()
buffer_clear_highlight :: Buffer -> Int64 -> Int64 -> Int64 -> forall env. Neovim env (Either NeovimException ())
buffer_add_highlight' :: Buffer -> Int64 -> String -> Int64 -> Int64 -> Int64 -> forall env. Neovim env Int64
buffer_add_highlight :: Buffer -> Int64 -> String -> Int64 -> Int64 -> Int64 -> forall env. Neovim env (Either NeovimException Int64)
buffer_get_mark' :: Buffer -> String -> forall env. Neovim env (Int64, Int64)
buffer_get_mark :: Buffer -> String -> forall env. Neovim env (Either NeovimException (Int64, Int64))
buffer_is_valid' :: Buffer -> forall env. Neovim env Bool
buffer_is_valid :: Buffer -> forall env. Neovim env (Either NeovimException Bool)
buffer_set_name' :: Buffer -> String -> forall env. Neovim env ()
buffer_set_name :: Buffer -> String -> forall env. Neovim env (Either NeovimException ())
buffer_get_name' :: Buffer -> forall env. Neovim env String
buffer_get_name :: Buffer -> forall env. Neovim env (Either NeovimException String)
buffer_get_number' :: Buffer -> forall env. Neovim env Int64
buffer_get_number :: Buffer -> forall env. Neovim env (Either NeovimException Int64)
buffer_set_option' :: Buffer -> String -> Object -> forall env. Neovim env ()
buffer_set_option :: Buffer -> String -> Object -> forall env. Neovim env (Either NeovimException ())
buffer_get_option' :: Buffer -> String -> forall env. Neovim env Object
buffer_get_option :: Buffer -> String -> forall env. Neovim env (Either NeovimException Object)
buffer_get_var' :: Buffer -> String -> forall env. Neovim env Object
buffer_get_var :: Buffer -> String -> forall env. Neovim env (Either NeovimException Object)
buffer_set_lines' :: Buffer -> Int64 -> Int64 -> Bool -> [String] -> forall env. Neovim env ()
buffer_set_lines :: Buffer -> Int64 -> Int64 -> Bool -> [String] -> forall env. Neovim env (Either NeovimException ())
buffer_get_lines' :: Buffer -> Int64 -> Int64 -> Bool -> forall env. Neovim env [String]
buffer_get_lines :: Buffer -> Int64 -> Int64 -> Bool -> forall env. Neovim env (Either NeovimException [String])
buffer_line_count' :: Buffer -> forall env. Neovim env Int64
buffer_line_count :: Buffer -> forall env. Neovim env (Either NeovimException Int64)
nvim_win_is_valid' :: Window -> forall env. Neovim env Bool
nvim_win_is_valid :: Window -> forall env. Neovim env (Either NeovimException Bool)
nvim_win_get_number' :: Window -> forall env. Neovim env Int64
nvim_win_get_number :: Window -> forall env. Neovim env (Either NeovimException Int64)
nvim_win_get_tabpage' :: Window -> forall env. Neovim env Tabpage
nvim_win_get_tabpage :: Window -> forall env. Neovim env (Either NeovimException Tabpage)
nvim_win_get_position' :: Window -> forall env. Neovim env (Int64, Int64)
nvim_win_get_position :: Window -> forall env. Neovim env (Either NeovimException (Int64, Int64))
nvim_win_set_option' :: Window -> String -> Object -> forall env. Neovim env ()
nvim_win_set_option :: Window -> String -> Object -> forall env. Neovim env (Either NeovimException ())
nvim_win_get_option' :: Window -> String -> forall env. Neovim env Object
nvim_win_get_option :: Window -> String -> forall env. Neovim env (Either NeovimException Object)
window_del_var' :: Window -> String -> forall env. Neovim env Object
window_del_var :: Window -> String -> forall env. Neovim env (Either NeovimException Object)
window_set_var' :: Window -> String -> Object -> forall env. Neovim env Object
window_set_var :: Window -> String -> Object -> forall env. Neovim env (Either NeovimException Object)
nvim_win_del_var' :: Window -> String -> forall env. Neovim env ()
nvim_win_del_var :: Window -> String -> forall env. Neovim env (Either NeovimException ())
nvim_win_set_var' :: Window -> String -> Object -> forall env. Neovim env ()
nvim_win_set_var :: Window -> String -> Object -> forall env. Neovim env (Either NeovimException ())
nvim_win_get_var' :: Window -> String -> forall env. Neovim env Object
nvim_win_get_var :: Window -> String -> forall env. Neovim env (Either NeovimException Object)
nvim_win_set_width' :: Window -> Int64 -> forall env. Neovim env ()
nvim_win_set_width :: Window -> Int64 -> forall env. Neovim env (Either NeovimException ())
nvim_win_get_width' :: Window -> forall env. Neovim env Int64
nvim_win_get_width :: Window -> forall env. Neovim env (Either NeovimException Int64)
nvim_win_set_height' :: Window -> Int64 -> forall env. Neovim env ()
nvim_win_set_height :: Window -> Int64 -> forall env. Neovim env (Either NeovimException ())
nvim_win_get_height' :: Window -> forall env. Neovim env Int64
nvim_win_get_height :: Window -> forall env. Neovim env (Either NeovimException Int64)
nvim_win_set_cursor' :: Window -> (Int64, Int64) -> forall env. Neovim env ()
nvim_win_set_cursor :: Window -> (Int64, Int64) -> forall env. Neovim env (Either NeovimException ())
nvim_win_get_cursor' :: Window -> forall env. Neovim env (Int64, Int64)
nvim_win_get_cursor :: Window -> forall env. Neovim env (Either NeovimException (Int64, Int64))
nvim_win_get_buf' :: Window -> forall env. Neovim env Buffer
nvim_win_get_buf :: Window -> forall env. Neovim env (Either NeovimException Buffer)
nvim_get_proc' :: Int64 -> forall env. Neovim env Object
nvim_get_proc :: Int64 -> forall env. Neovim env (Either NeovimException Object)
nvim_get_proc_children' :: Int64 -> forall env. Neovim env [Object]
nvim_get_proc_children :: Int64 -> forall env. Neovim env (Either NeovimException [Object])
nvim_list_uis' :: forall env. Neovim env [Object]
nvim_list_uis :: forall env. Neovim env (Either NeovimException [Object])
nvim_parse_expression' :: String -> String -> Bool -> forall env. Neovim env (Map Object Object)
nvim_parse_expression :: String -> String -> Bool -> forall env. Neovim env (Either NeovimException (Map Object Object))
nvim_call_atomic' :: [Object] -> forall env. Neovim env [Object]
nvim_call_atomic :: [Object] -> forall env. Neovim env (Either NeovimException [Object])
nvim_list_chans' :: forall env. Neovim env [Object]
nvim_list_chans :: forall env. Neovim env (Either NeovimException [Object])
nvim_get_chan_info' :: Int64 -> forall env. Neovim env (Map Object Object)
nvim_get_chan_info :: Int64 -> forall env. Neovim env (Either NeovimException (Map Object Object))
nvim_set_client_info' :: String -> Map Object Object -> String -> Map Object Object -> Map Object Object -> forall env. Neovim env ()
nvim_set_client_info :: String -> Map Object Object -> String -> Map Object Object -> Map Object Object -> forall env. Neovim env (Either NeovimException ())
nvim_get_api_info' :: forall env. Neovim env [Object]
nvim_get_api_info :: forall env. Neovim env (Either NeovimException [Object])
nvim_get_commands' :: Map Object Object -> forall env. Neovim env (Map Object Object)
nvim_get_commands :: Map Object Object -> forall env. Neovim env (Either NeovimException (Map Object Object))
nvim_get_keymap' :: String -> forall env. Neovim env [Map Object Object]
nvim_get_keymap :: String -> forall env. Neovim env (Either NeovimException [Map Object Object])
nvim_get_mode' :: forall env. Neovim env (Map Object Object)
nvim_get_mode :: forall env. Neovim env (Either NeovimException (Map Object Object))
nvim_get_color_map' :: forall env. Neovim env (Map Object Object)
nvim_get_color_map :: forall env. Neovim env (Either NeovimException (Map Object Object))
nvim_get_color_by_name' :: String -> forall env. Neovim env Int64
nvim_get_color_by_name :: String -> forall env. Neovim env (Either NeovimException Int64)
nvim_unsubscribe' :: String -> forall env. Neovim env ()
nvim_unsubscribe :: String -> forall env. Neovim env (Either NeovimException ())
nvim_subscribe' :: String -> forall env. Neovim env ()
nvim_subscribe :: String -> forall env. Neovim env (Either NeovimException ())
nvim_set_current_tabpage' :: Tabpage -> forall env. Neovim env ()
nvim_set_current_tabpage :: Tabpage -> forall env. Neovim env (Either NeovimException ())
nvim_get_current_tabpage' :: forall env. Neovim env Tabpage
nvim_get_current_tabpage :: forall env. Neovim env (Either NeovimException Tabpage)
nvim_list_tabpages' :: forall env. Neovim env [Tabpage]
nvim_list_tabpages :: forall env. Neovim env (Either NeovimException [Tabpage])
nvim_set_current_win' :: Window -> forall env. Neovim env ()
nvim_set_current_win :: Window -> forall env. Neovim env (Either NeovimException ())
nvim_get_current_win' :: forall env. Neovim env Window
nvim_get_current_win :: forall env. Neovim env (Either NeovimException Window)
nvim_list_wins' :: forall env. Neovim env [Window]
nvim_list_wins :: forall env. Neovim env (Either NeovimException [Window])
nvim_set_current_buf' :: Buffer -> forall env. Neovim env ()
nvim_set_current_buf :: Buffer -> forall env. Neovim env (Either NeovimException ())
nvim_get_current_buf' :: forall env. Neovim env Buffer
nvim_get_current_buf :: forall env. Neovim env (Either NeovimException Buffer)
nvim_list_bufs' :: forall env. Neovim env [Buffer]
nvim_list_bufs :: forall env. Neovim env (Either NeovimException [Buffer])
nvim_err_writeln' :: String -> forall env. Neovim env ()
nvim_err_writeln :: String -> forall env. Neovim env (Either NeovimException ())
nvim_err_write' :: String -> forall env. Neovim env ()
nvim_err_write :: String -> forall env. Neovim env (Either NeovimException ())
nvim_out_write' :: String -> forall env. Neovim env ()
nvim_out_write :: String -> forall env. Neovim env (Either NeovimException ())
nvim_set_option' :: String -> Object -> forall env. Neovim env ()
nvim_set_option :: String -> Object -> forall env. Neovim env (Either NeovimException ())
nvim_get_option' :: String -> forall env. Neovim env Object
nvim_get_option :: String -> forall env. Neovim env (Either NeovimException Object)
nvim_get_vvar' :: String -> forall env. Neovim env Object
nvim_get_vvar :: String -> forall env. Neovim env (Either NeovimException Object)
vim_del_var' :: String -> forall env. Neovim env Object
vim_del_var :: String -> forall env. Neovim env (Either NeovimException Object)
vim_set_var' :: String -> Object -> forall env. Neovim env Object
vim_set_var :: String -> Object -> forall env. Neovim env (Either NeovimException Object)
nvim_del_var' :: String -> forall env. Neovim env ()
nvim_del_var :: String -> forall env. Neovim env (Either NeovimException ())
nvim_set_var' :: String -> Object -> forall env. Neovim env ()
nvim_set_var :: String -> Object -> forall env. Neovim env (Either NeovimException ())
nvim_get_var' :: String -> forall env. Neovim env Object
nvim_get_var :: String -> forall env. Neovim env (Either NeovimException Object)
nvim_del_current_line' :: forall env. Neovim env ()
nvim_del_current_line :: forall env. Neovim env (Either NeovimException ())
nvim_set_current_line' :: String -> forall env. Neovim env ()
nvim_set_current_line :: String -> forall env. Neovim env (Either NeovimException ())
nvim_get_current_line' :: forall env. Neovim env String
nvim_get_current_line :: forall env. Neovim env (Either NeovimException String)
nvim_set_current_dir' :: String -> forall env. Neovim env ()
nvim_set_current_dir :: String -> forall env. Neovim env (Either NeovimException ())
nvim_list_runtime_paths' :: forall env. Neovim env [String]
nvim_list_runtime_paths :: forall env. Neovim env (Either NeovimException [String])
nvim_strwidth' :: String -> forall env. Neovim env Int64
nvim_strwidth :: String -> forall env. Neovim env (Either NeovimException Int64)
nvim_call_dict_function' :: Object -> String -> [Object] -> forall env. Neovim env Object
nvim_call_dict_function :: Object -> String -> [Object] -> forall env. Neovim env (Either NeovimException Object)
nvim_call_function' :: String -> [Object] -> forall env. Neovim env Object
nvim_call_function :: String -> [Object] -> forall env. Neovim env (Either NeovimException Object)
nvim_execute_lua' :: String -> [Object] -> forall env. Neovim env Object
nvim_execute_lua :: String -> [Object] -> forall env. Neovim env (Either NeovimException Object)
nvim_eval' :: String -> forall env. Neovim env Object
nvim_eval :: String -> forall env. Neovim env (Either NeovimException Object)
nvim_command_output' :: String -> forall env. Neovim env String
nvim_command_output :: String -> forall env. Neovim env (Either NeovimException String)
nvim_replace_termcodes' :: String -> Bool -> Bool -> Bool -> forall env. Neovim env String
nvim_replace_termcodes :: String -> Bool -> Bool -> Bool -> forall env. Neovim env (Either NeovimException String)
nvim_input' :: String -> forall env. Neovim env Int64
nvim_input :: String -> forall env. Neovim env (Either NeovimException Int64)
nvim_feedkeys' :: String -> String -> Bool -> forall env. Neovim env ()
nvim_feedkeys :: String -> String -> Bool -> forall env. Neovim env (Either NeovimException ())
nvim_get_hl_by_id' :: Int64 -> Bool -> forall env. Neovim env (Map Object Object)
nvim_get_hl_by_id :: Int64 -> Bool -> forall env. Neovim env (Either NeovimException (Map Object Object))
nvim_get_hl_by_name' :: String -> Bool -> forall env. Neovim env (Map Object Object)
nvim_get_hl_by_name :: String -> Bool -> forall env. Neovim env (Either NeovimException (Map Object Object))
nvim_command' :: String -> forall env. Neovim env ()
nvim_command :: String -> forall env. Neovim env (Either NeovimException ())
nvim_ui_set_option' :: String -> Object -> forall env. Neovim env ()
nvim_ui_set_option :: String -> Object -> forall env. Neovim env (Either NeovimException ())
nvim_ui_try_resize' :: Int64 -> Int64 -> forall env. Neovim env ()
nvim_ui_try_resize :: Int64 -> Int64 -> forall env. Neovim env (Either NeovimException ())
nvim_ui_detach' :: forall env. Neovim env ()
nvim_ui_detach :: forall env. Neovim env (Either NeovimException ())
ui_attach' :: Int64 -> Int64 -> Bool -> forall env. Neovim env ()
ui_attach :: Int64 -> Int64 -> Bool -> forall env. Neovim env (Either NeovimException ())
nvim_ui_attach' :: Int64 -> Int64 -> Map Object Object -> forall env. Neovim env ()
nvim_ui_attach :: Int64 -> Int64 -> Map Object Object -> forall env. Neovim env (Either NeovimException ())
nvim_tabpage_is_valid' :: Tabpage -> forall env. Neovim env Bool
nvim_tabpage_is_valid :: Tabpage -> forall env. Neovim env (Either NeovimException Bool)
nvim_tabpage_get_number' :: Tabpage -> forall env. Neovim env Int64
nvim_tabpage_get_number :: Tabpage -> forall env. Neovim env (Either NeovimException Int64)
nvim_tabpage_get_win' :: Tabpage -> forall env. Neovim env Window
nvim_tabpage_get_win :: Tabpage -> forall env. Neovim env (Either NeovimException Window)
tabpage_del_var' :: Tabpage -> String -> forall env. Neovim env Object
tabpage_del_var :: Tabpage -> String -> forall env. Neovim env (Either NeovimException Object)
tabpage_set_var' :: Tabpage -> String -> Object -> forall env. Neovim env Object
tabpage_set_var :: Tabpage -> String -> Object -> forall env. Neovim env (Either NeovimException Object)
nvim_tabpage_del_var' :: Tabpage -> String -> forall env. Neovim env ()
nvim_tabpage_del_var :: Tabpage -> String -> forall env. Neovim env (Either NeovimException ())
nvim_tabpage_set_var' :: Tabpage -> String -> Object -> forall env. Neovim env ()
nvim_tabpage_set_var :: Tabpage -> String -> Object -> forall env. Neovim env (Either NeovimException ())
nvim_tabpage_get_var' :: Tabpage -> String -> forall env. Neovim env Object
nvim_tabpage_get_var :: Tabpage -> String -> forall env. Neovim env (Either NeovimException Object)
nvim_tabpage_list_wins' :: Tabpage -> forall env. Neovim env [Window]
nvim_tabpage_list_wins :: Tabpage -> forall env. Neovim env (Either NeovimException [Window])
nvim_buf_clear_highlight' :: Buffer -> Int64 -> Int64 -> Int64 -> forall env. Neovim env ()
nvim_buf_clear_highlight :: Buffer -> Int64 -> Int64 -> Int64 -> forall env. Neovim env (Either NeovimException ())
nvim_buf_add_highlight' :: Buffer -> Int64 -> String -> Int64 -> Int64 -> Int64 -> forall env. Neovim env Int64
nvim_buf_add_highlight :: Buffer -> Int64 -> String -> Int64 -> Int64 -> Int64 -> forall env. Neovim env (Either NeovimException Int64)
nvim_buf_get_mark' :: Buffer -> String -> forall env. Neovim env (Int64, Int64)
nvim_buf_get_mark :: Buffer -> String -> forall env. Neovim env (Either NeovimException (Int64, Int64))
buffer_insert' :: Buffer -> Int64 -> [String] -> forall env. Neovim env ()
buffer_insert :: Buffer -> Int64 -> [String] -> forall env. Neovim env (Either NeovimException ())
nvim_buf_is_valid' :: Buffer -> forall env. Neovim env Bool
nvim_buf_is_valid :: Buffer -> forall env. Neovim env (Either NeovimException Bool)
nvim_buf_set_name' :: Buffer -> String -> forall env. Neovim env ()
nvim_buf_set_name :: Buffer -> String -> forall env. Neovim env (Either NeovimException ())
nvim_buf_get_name' :: Buffer -> forall env. Neovim env String
nvim_buf_get_name :: Buffer -> forall env. Neovim env (Either NeovimException String)
nvim_buf_get_number' :: Buffer -> forall env. Neovim env Int64
nvim_buf_get_number :: Buffer -> forall env. Neovim env (Either NeovimException Int64)
nvim_buf_set_option' :: Buffer -> String -> Object -> forall env. Neovim env ()
nvim_buf_set_option :: Buffer -> String -> Object -> forall env. Neovim env (Either NeovimException ())
nvim_buf_get_option' :: Buffer -> String -> forall env. Neovim env Object
nvim_buf_get_option :: Buffer -> String -> forall env. Neovim env (Either NeovimException Object)
buffer_del_var' :: Buffer -> String -> forall env. Neovim env Object
buffer_del_var :: Buffer -> String -> forall env. Neovim env (Either NeovimException Object)
buffer_set_var' :: Buffer -> String -> Object -> forall env. Neovim env Object
buffer_set_var :: Buffer -> String -> Object -> forall env. Neovim env (Either NeovimException Object)
nvim_buf_del_var' :: Buffer -> String -> forall env. Neovim env ()
nvim_buf_del_var :: Buffer -> String -> forall env. Neovim env (Either NeovimException ())
nvim_buf_set_var' :: Buffer -> String -> Object -> forall env. Neovim env ()
nvim_buf_set_var :: Buffer -> String -> Object -> forall env. Neovim env (Either NeovimException ())
nvim_buf_get_commands' :: Buffer -> Map Object Object -> forall env. Neovim env (Map Object Object)
nvim_buf_get_commands :: Buffer -> Map Object Object -> forall env. Neovim env (Either NeovimException (Map Object Object))
nvim_buf_get_keymap' :: Buffer -> String -> forall env. Neovim env [Map Object Object]
nvim_buf_get_keymap :: Buffer -> String -> forall env. Neovim env (Either NeovimException [Map Object Object])
nvim_buf_get_changedtick' :: Buffer -> forall env. Neovim env Int64
nvim_buf_get_changedtick :: Buffer -> forall env. Neovim env (Either NeovimException Int64)
nvim_buf_get_var' :: Buffer -> String -> forall env. Neovim env Object
nvim_buf_get_var :: Buffer -> String -> forall env. Neovim env (Either NeovimException Object)
nvim_buf_set_lines' :: Buffer -> Int64 -> Int64 -> Bool -> [String] -> forall env. Neovim env ()
nvim_buf_set_lines :: Buffer -> Int64 -> Int64 -> Bool -> [String] -> forall env. Neovim env (Either NeovimException ())
buffer_set_line_slice' :: Buffer -> Int64 -> Int64 -> Bool -> Bool -> [String] -> forall env. Neovim env ()
buffer_set_line_slice :: Buffer -> Int64 -> Int64 -> Bool -> Bool -> [String] -> forall env. Neovim env (Either NeovimException ())
nvim_buf_get_lines' :: Buffer -> Int64 -> Int64 -> Bool -> forall env. Neovim env [String]
nvim_buf_get_lines :: Buffer -> Int64 -> Int64 -> Bool -> forall env. Neovim env (Either NeovimException [String])
buffer_get_line_slice' :: Buffer -> Int64 -> Int64 -> Bool -> Bool -> forall env. Neovim env [String]
buffer_get_line_slice :: Buffer -> Int64 -> Int64 -> Bool -> Bool -> forall env. Neovim env (Either NeovimException [String])
buffer_del_line' :: Buffer -> Int64 -> forall env. Neovim env ()
buffer_del_line :: Buffer -> Int64 -> forall env. Neovim env (Either NeovimException ())
buffer_set_line' :: Buffer -> Int64 -> String -> forall env. Neovim env ()
buffer_set_line :: Buffer -> Int64 -> String -> forall env. Neovim env (Either NeovimException ())
nvim_buf_detach' :: Buffer -> forall env. Neovim env Bool
nvim_buf_detach :: Buffer -> forall env. Neovim env (Either NeovimException Bool)
nvim_buf_attach' :: Buffer -> Bool -> Map Object Object -> forall env. Neovim env Bool
nvim_buf_attach :: Buffer -> Bool -> Map Object Object -> forall env. Neovim env (Either NeovimException Bool)
buffer_get_line' :: Buffer -> Int64 -> forall env. Neovim env String
buffer_get_line :: Buffer -> Int64 -> forall env. Neovim env (Either NeovimException String)
nvim_buf_line_count' :: Buffer -> forall env. Neovim env Int64
nvim_buf_line_count :: Buffer -> forall env. Neovim env (Either NeovimException Int64)
instance GHC.Generics.Generic Neovim.API.String.Window
instance GHC.Show.Show Neovim.API.String.Window
instance GHC.Classes.Eq Neovim.API.String.Window
instance GHC.Generics.Generic Neovim.API.String.Tabpage
instance GHC.Show.Show Neovim.API.String.Tabpage
instance GHC.Classes.Eq Neovim.API.String.Tabpage
instance GHC.Generics.Generic Neovim.API.String.Buffer
instance GHC.Show.Show Neovim.API.String.Buffer
instance GHC.Classes.Eq Neovim.API.String.Buffer
instance GHC.Generics.Generic Neovim.API.String.NeovimExceptionGen
instance GHC.Show.Show Neovim.API.String.NeovimExceptionGen
instance GHC.Classes.Eq Neovim.API.String.NeovimExceptionGen
instance Control.DeepSeq.NFData Neovim.API.String.Window
instance Neovim.Classes.NvimObject Neovim.API.String.Window
instance Control.DeepSeq.NFData Neovim.API.String.Tabpage
instance Neovim.Classes.NvimObject Neovim.API.String.Tabpage
instance Control.DeepSeq.NFData Neovim.API.String.Buffer
instance Neovim.Classes.NvimObject Neovim.API.String.Buffer
instance Control.DeepSeq.NFData Neovim.API.String.NeovimExceptionGen
instance GHC.Exception.Exception Neovim.API.String.NeovimExceptionGen
instance Neovim.Classes.NvimObject Neovim.API.String.NeovimExceptionGen


module Neovim.Quickfix

-- | This is a wrapper around neovim's <tt>setqflist()</tt>.
--   <tt>strType</tt> can be any string that you can append to (hence
--   <a>Monoid</a>) that is also an instance of <a>NvimObject</a>. You can
--   e.g. use the plain old <a>String</a>.
setqflist :: (Monoid strType, NvimObject strType) => [QuickfixListItem strType] -> QuickfixAction -> Neovim env ()
data ColumnNumber
VisualColumn :: Int -> ColumnNumber
ByteIndexColumn :: Int -> ColumnNumber
NoColumn :: ColumnNumber
data SignLocation strType
LineNumber :: Int -> SignLocation strType
SearchPattern :: strType -> SignLocation strType

-- | Quickfix list item. The parameter names should mostly conform to those
--   in <tt>:h setqflist()</tt>. Some fields are merged to explicitly state
--   mutually exclusive elements or some other behavior of the fields.
--   
--   see <a>quickfixListItem</a> for creating a value of this type without
--   typing too much.
data QuickfixListItem strType
QFItem :: Either Int strType -> Either Int strType -> ColumnNumber -> Maybe Int -> strType -> QuickfixErrorType -> QuickfixListItem strType

-- | Since the filename is only used if no buffer can be specified, this
--   field is a merge of <tt>bufnr</tt> and <tt>filename</tt>.
[bufOrFile] :: QuickfixListItem strType -> Either Int strType

-- | Line number or search pattern to locate the error.
[lnumOrPattern] :: QuickfixListItem strType -> Either Int strType

-- | A tuple of a column number and a boolean indicating which kind of
--   indexing should be used. <a>True</a> means that the visual column
--   should be used. <a>False</a> means to use the byte index.
[col] :: QuickfixListItem strType -> ColumnNumber

-- | Error number.
[nr] :: QuickfixListItem strType -> Maybe Int

-- | Description of the error.
[text] :: QuickfixListItem strType -> strType

-- | Type of error.
[errorType] :: QuickfixListItem strType -> QuickfixErrorType

-- | Simple error type enum.
data QuickfixErrorType
Warning :: QuickfixErrorType
Error :: QuickfixErrorType

-- | Create a <a>QuickfixListItem</a> by providing the minimal amount of
--   arguments needed.
quickfixListItem :: (Monoid strType) => Either Int strType -> Either Int strType -> QuickfixListItem strType
data QuickfixAction

-- | Add items to the current list (or create a new one if none exists).
Append :: QuickfixAction

-- | Replace current list (or create a new one if none exists).
Replace :: QuickfixAction

-- | Create a new list.
New :: QuickfixAction
instance GHC.Generics.Generic Neovim.Quickfix.QuickfixAction
instance GHC.Show.Show Neovim.Quickfix.QuickfixAction
instance GHC.Enum.Bounded Neovim.Quickfix.QuickfixAction
instance GHC.Enum.Enum Neovim.Quickfix.QuickfixAction
instance GHC.Classes.Ord Neovim.Quickfix.QuickfixAction
instance GHC.Classes.Eq Neovim.Quickfix.QuickfixAction
instance GHC.Generics.Generic (Neovim.Quickfix.QuickfixListItem strType)
instance GHC.Show.Show strType => GHC.Show.Show (Neovim.Quickfix.QuickfixListItem strType)
instance GHC.Classes.Eq strType => GHC.Classes.Eq (Neovim.Quickfix.QuickfixListItem strType)
instance GHC.Generics.Generic Neovim.Quickfix.QuickfixErrorType
instance GHC.Enum.Bounded Neovim.Quickfix.QuickfixErrorType
instance GHC.Enum.Enum Neovim.Quickfix.QuickfixErrorType
instance GHC.Read.Read Neovim.Quickfix.QuickfixErrorType
instance GHC.Show.Show Neovim.Quickfix.QuickfixErrorType
instance GHC.Classes.Ord Neovim.Quickfix.QuickfixErrorType
instance GHC.Classes.Eq Neovim.Quickfix.QuickfixErrorType
instance GHC.Generics.Generic (Neovim.Quickfix.SignLocation strType)
instance GHC.Show.Show strType => GHC.Show.Show (Neovim.Quickfix.SignLocation strType)
instance GHC.Classes.Ord strType => GHC.Classes.Ord (Neovim.Quickfix.SignLocation strType)
instance GHC.Classes.Eq strType => GHC.Classes.Eq (Neovim.Quickfix.SignLocation strType)
instance GHC.Generics.Generic Neovim.Quickfix.ColumnNumber
instance GHC.Show.Show Neovim.Quickfix.ColumnNumber
instance GHC.Classes.Ord Neovim.Quickfix.ColumnNumber
instance GHC.Classes.Eq Neovim.Quickfix.ColumnNumber
instance Control.DeepSeq.NFData Neovim.Quickfix.QuickfixAction
instance Neovim.Classes.NvimObject Neovim.Quickfix.QuickfixAction
instance Control.DeepSeq.NFData strType => Control.DeepSeq.NFData (Neovim.Quickfix.QuickfixListItem strType)
instance (GHC.Base.Monoid strType, Neovim.Classes.NvimObject strType) => Neovim.Classes.NvimObject (Neovim.Quickfix.QuickfixListItem strType)
instance Control.DeepSeq.NFData Neovim.Quickfix.QuickfixErrorType
instance Neovim.Classes.NvimObject Neovim.Quickfix.QuickfixErrorType
instance Control.DeepSeq.NFData strType => Control.DeepSeq.NFData (Neovim.Quickfix.SignLocation strType)
instance Control.DeepSeq.NFData Neovim.Quickfix.ColumnNumber


module Neovim.Plugin
startPluginThreads :: Config StartupConfig -> [Neovim StartupConfig NeovimPlugin] -> IO (Either (Doc AnsiStyle) ([FunctionMapEntry], [Async ()]))
type StartupConfig = StartupConfig NeovimConfig

-- | Wrap a <a>Plugin</a> in some nice blankets, so that we can put them in
--   a simple list.
wrapPlugin :: Applicative m => Plugin env -> m NeovimPlugin

-- | <a>Plugin</a> values are wraped inside this data type via
--   <a>wrapPlugin</a> so that we can put plugins in an ordinary list.
data NeovimPlugin

-- | This data type contains meta information for the plugin manager.
data Plugin env
Plugin :: env -> [ExportedFunctionality env] -> Plugin env
[environment] :: Plugin env -> env
[exports] :: Plugin env -> [ExportedFunctionality env]

-- | This option detemines how neovim should behave when calling some
--   functionality on a remote host.
data Synchronous

-- | 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.
Async :: Synchronous

-- | 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.
Sync :: Synchronous

-- | Options for commands.
--   
--   Some command can also be described by using the OverloadedString
--   extensions. This means that you can write a literal <a>String</a>
--   inside your source file in place for a <a>CommandOption</a> value. See
--   the documentation for each value on how these strings should look like
--   (Both versions are compile time checked.)
data CommandOption

-- | Stringliteral "sync" or "async"
CmdSync :: Synchronous -> CommandOption

-- | Register passed to the command.
--   
--   Stringliteral: <tt>"\""</tt>
CmdRegister :: CommandOption

-- | Command takes a specific amount of arguments
--   
--   Automatically set via template haskell functions. You really shouldn't
--   use this option yourself unless you have to.
CmdNargs :: String -> CommandOption

-- | Determines how neovim passes the range.
--   
--   Stringliterals: "%" for <a>WholeFile</a>, "," for line and ",123" for
--   123 lines.
CmdRange :: RangeSpecification -> CommandOption

-- | Command handles a count. The argument defines the default count.
--   
--   Stringliteral: string of numbers (e.g. "132")
CmdCount :: Word -> CommandOption

-- | Command handles a bang
--   
--   Stringliteral: "!"
CmdBang :: CommandOption

-- | 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. .
--   
--   Note that the function you pass must be fully applied.
addAutocmd :: ByteString -> AutocmdOptions -> (Neovim env ()) -> Neovim env (Maybe (Either (Neovim anyEnv ()) ReleaseKey))
registerPlugin :: (FunctionMapEntry -> Neovim env ()) -> FunctionalityDescription -> ([Object] -> Neovim env Object) -> TQueue SomeMessage -> TVar (Map FunctionName ([Object] -> Neovim env Object)) -> Neovim env (Maybe FunctionMapEntry)


module Neovim.RPC.SocketReader

-- | This function will establish a connection to the given socket and read
--   msgpack-rpc events from it.
runSocketReader :: Handle -> Config RPCConfig -> IO ()
parseParams :: FunctionalityDescription -> [Object] -> [Object]


module Neovim.Util

-- | Execute the given action with a changed set of environment variables
--   and restore the original state of the environment afterwards.
withCustomEnvironment :: (Traversable t, MonadUnliftIO m) => t (String, Maybe String) -> m c -> m c

-- | <a>when</a> with a monadic predicate.
whenM :: (Monad m) => m Bool -> m () -> m ()

-- | <a>unless</a> with a monadic predicate.
unlessM :: (Monad m) => m Bool -> m () -> m ()
oneLineErrorMessage :: Doc AnsiStyle -> Text


module Neovim.Plugin.ConfigHelper.Internal

-- | Simple function that will return <tt><a>Pong</a></tt> if the plugin
--   provider is running.
pingNvimhs :: Neovim env String
data ConfigHelperEnv
ConfigHelperEnv :: Params NeovimConfig -> [(String, Maybe String)] -> TVar [QuickfixListItem String] -> ConfigHelperEnv
[dyreParameters] :: ConfigHelperEnv -> Params NeovimConfig
[environmentVariables] :: ConfigHelperEnv -> [(String, Maybe String)]
[quickfixList] :: ConfigHelperEnv -> TVar [QuickfixListItem String]

-- | Recompile the plugin provider and put comile errors in the quickfix
--   list.
recompileNvimhs :: Neovim ConfigHelperEnv ()

-- | Note 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
--   <i>nvim-hs</i> is forcibly removed.
restartNvimhs :: CommandArguments -> Neovim ConfigHelperEnv ()
parseQuickfixItems :: String -> [QuickfixListItem String]
pQuickfixListItem :: Parser (QuickfixListItem String)
pSeverity :: Parser QuickfixErrorType
pShortDesrciption :: Parser String
pLongDescription :: Parser String
tabOrSpace :: Parser Char
blankLine :: Parser ()

-- | 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.
--   
--   <pre>
--   /some/path/to/a/file.hs:42:88:
--   </pre>
pLocation :: Parser (String, Int, Int)
pInt :: Parser Int


module Neovim.Plugin.ConfigHelper
plugin :: Neovim (StartupConfig NeovimConfig) NeovimPlugin


module Neovim.Main
logger :: String
data CommandLineOptions
Opt :: Maybe String -> Maybe (String, Int) -> Maybe FilePath -> Bool -> Maybe (FilePath, Priority) -> CommandLineOptions
[providerName] :: CommandLineOptions -> Maybe String
[hostPort] :: CommandLineOptions -> Maybe (String, Int)
[unix] :: CommandLineOptions -> Maybe FilePath
[envVar] :: CommandLineOptions -> Bool
[logOpts] :: CommandLineOptions -> Maybe (FilePath, Priority)
optParser :: Parser CommandLineOptions
opts :: ParserInfo CommandLineOptions

-- | This is essentially the main function for <i>nvim-hs</i>, at least if
--   you want to use <a>Config.Dyre</a> for the configuration.
neovim :: NeovimConfig -> IO ()

-- | A <a>TransitionHandler</a> function receives the <a>ThreadId</a>s of
--   all running threads which have been started by the plugin provider as
--   well as the <a>Config</a> with the custom field set to
--   <a>RPCConfig</a>. 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.
type TransitionHandler a = [Async ()] -> Config RPCConfig -> IO a

-- | This main functions can be used to create a custom executable without
--   using the <a>Config.Dyre</a> library while still using the
--   <i>nvim-hs</i> specific configuration facilities.
realMain :: TransitionHandler a -> Maybe (Params NeovimConfig) -> NeovimConfig -> IO ()

-- | Generic main function. Most arguments are optional or have sane
--   defaults.
runPluginProvider :: CommandLineOptions -> Maybe NeovimConfig -> TransitionHandler a -> Maybe (Params NeovimConfig) -> IO a

-- | If the plugin provider is started with dyre, this handler is used to
--   handle a restart.
finishDyre :: TransitionHandler ()
instance Data.Default.Class.Default Neovim.Main.CommandLineOptions


-- | This module should contain all the things you need to write neovim
--   plugins in your favorite language! <tt>:-)</tt>
--   
--   The documentation in this module should provide every information you
--   need to start writing plugins.
module Neovim

-- | This 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 <a>IO</a> in general haskell programs.
data Neovim env a

-- | This is essentially the main function for <i>nvim-hs</i>, at least if
--   you want to use <a>Config.Dyre</a> for the configuration.
neovim :: NeovimConfig -> IO ()

-- | This 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 <a>Neovim</a> module should get you started.
data NeovimConfig
Config :: [Neovim (StartupConfig NeovimConfig) NeovimPlugin] -> Maybe (FilePath, Priority) -> Maybe String -> NeovimConfig

-- | The 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 <a>NeovimPlugin</a>.
[plugins] :: NeovimConfig -> [Neovim (StartupConfig NeovimConfig) NeovimPlugin]

-- | Set the general logging options.
[logOptions] :: NeovimConfig -> Maybe (FilePath, Priority)

-- | Internally used field. Changing this has no effect.
--   
--   Used by <tt>Dyre</tt> for storing compilation errors.
[errorMessage] :: NeovimConfig -> Maybe String

-- | Default configuration options for <i>nvim-hs</i>. If you want to keep
--   the default plugins enabled, you can define your config like this:
--   
--   <pre>
--   main = <a>neovim</a> <a>defaultConfig</a>
--            { plugins = myPlugins ++ plugins defaultConfig
--            }
--   </pre>
defaultConfig :: NeovimConfig

-- | This data type contains internal fields of <i>nvim-hs</i> that may be
--   useful for plugin authors. It is available via <tt>ask</tt> inside the
--   plugin startup code.
data StartupConfig cfg
StartupConfig :: Maybe (Params cfg) -> [(String, Maybe String)] -> StartupConfig cfg

-- | The configuration options for <a>Config.Dyre</a>. This is always set
--   if <i>nvim-hs</i> has been started via <a>Config.Dyre</a>. Be sure to
--   set up the <a>ghcEnvironmentVariables</a> correctly if you issue a
--   recompilation via the <a>Config.Dyre</a> API.
[dyreParams] :: StartupConfig cfg -> Maybe (Params cfg)

-- | The GHC environment variables with which <i>nvim-hs</i> has been
--   started. This are mainly of significance if you want to use the same
--   environment for compilation or a REPL that <i>nvim-hs</i> runs on.
--   
--   These variables have to be used if you want to invoke functionality of
--   <a>Config.Dyre</a> targeting <i>nvim-hs</i>.
[ghcEnvironmentVariables] :: StartupConfig cfg -> [(String, Maybe String)]

-- | The default value for this type.
def :: Default a => a

-- | <a>Plugin</a> values are wraped inside this data type via
--   <a>wrapPlugin</a> so that we can put plugins in an ordinary list.
data NeovimPlugin
NeovimPlugin :: (Plugin env) -> NeovimPlugin

-- | This data type contains meta information for the plugin manager.
data Plugin env
Plugin :: env -> [ExportedFunctionality env] -> Plugin env
[environment] :: Plugin env -> env
[exports] :: Plugin env -> [ExportedFunctionality env]

-- | Conversion from <a>Object</a> files to Haskell types and back with
--   respect to neovim's interpretation.
--   
--   The <a>NFData</a> 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.
class NFData o => NvimObject o
toObject :: NvimObject o => o -> Object
fromObjectUnsafe :: NvimObject o => Object -> o
fromObject :: NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject' :: (NvimObject o, (MonadIO io)) => Object -> io o

-- | Convenient operator to create a list of <a>Object</a> from normal
--   values. <tt> values +: of :+ different :+ types :+ can +: be +:
--   combined +: this +: way +: [] </tt>
(+:) :: (NvimObject o) => o -> [Object] -> [Object]
infixr 5 +:

-- | 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.
type Dictionary = Map ByteString Object
data Object :: *
ObjectNil :: Object

-- | Unsigned integers from the MsgPack protocol: uint 8, uint 16, uint 32,
--   uint 64
ObjectUInt :: Word64 -> Object

-- | Signed integers and fixnums from the MsgPack protocol: positive
--   fixnum, negative fixnum, int 8, int 16, int 32, int 64
ObjectInt :: Int64 -> Object
ObjectBool :: Bool -> Object
ObjectFloat :: Float -> Object
ObjectDouble :: Double -> Object
ObjectString :: ByteString -> Object
ObjectBinary :: ByteString -> Object
ObjectArray :: [Object] -> Object
ObjectMap :: Map Object Object -> Object
ObjectExt :: !Int8 -> ByteString -> Object

-- | Wrap a <a>Plugin</a> in some nice blankets, so that we can put them in
--   a simple list.
wrapPlugin :: Applicative m => Plugin env -> m NeovimPlugin

-- | Define an exported function by providing a custom name and referencing
--   the function you want to export.
--   
--   Note that the name must start with an upper case letter.
--   
--   Example: <tt> $(function "MyExportedFunction" 'myDefinedFunction)
--   <tt>Sync</tt> </tt>
function :: String -> Name -> Q Exp

-- | Define an exported function. This function works exactly like
--   <a>function</a>, but it generates the exported name automatically by
--   converting the first letter to upper case.
function' :: Name -> Q Exp

-- | Similarly to <a>function</a>, this function is used to export a
--   command with a custom name.
--   
--   Note 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 <a>String</a>
--   with <a>ByteString</a> or <a>Text</a> if you wish:
--   
--   <ul>
--   <li><a>CommandArguments</a> -&gt; <a>Neovim</a> r st ()</li>
--   <li><a>CommandArguments</a> -&gt; <a>Maybe</a> <a>String</a> -&gt;
--   <a>Neovim</a> r st ()</li>
--   <li><a>CommandArguments</a> -&gt; <a>String</a> -&gt; <a>Neovim</a> r
--   st ()</li>
--   <li><a>CommandArguments</a> -&gt; [<a>String</a>] -&gt; <a>Neovim</a>
--   r st ()</li>
--   <li><a>CommandArguments</a> -&gt; <a>String</a> -&gt; [<a>String</a>]
--   -&gt; <a>Neovim</a> r st ()</li>
--   </ul>
--   
--   Example: <tt> $(command "RememberThePrime" 'someFunction)
--   [<a>CmdBang</a>] </tt>
--   
--   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.
command :: String -> Name -> Q Exp

-- | Define an exported command. This function works exactly like
--   <a>command</a>, but it generates the command name by converting the
--   first letter to upper case.
command' :: Name -> Q Exp
autocmd :: Name -> Q Exp

-- | This option detemines how neovim should behave when calling some
--   functionality on a remote host.
data Synchronous

-- | 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.
Async :: Synchronous

-- | 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.
Sync :: Synchronous

-- | Options for commands.
--   
--   Some command can also be described by using the OverloadedString
--   extensions. This means that you can write a literal <a>String</a>
--   inside your source file in place for a <a>CommandOption</a> value. See
--   the documentation for each value on how these strings should look like
--   (Both versions are compile time checked.)
data CommandOption

-- | Stringliteral "sync" or "async"
CmdSync :: Synchronous -> CommandOption

-- | Register passed to the command.
--   
--   Stringliteral: <tt>"\""</tt>
CmdRegister :: CommandOption

-- | Determines how neovim passes the range.
--   
--   Stringliterals: "%" for <a>WholeFile</a>, "," for line and ",123" for
--   123 lines.
CmdRange :: RangeSpecification -> CommandOption

-- | Command handles a count. The argument defines the default count.
--   
--   Stringliteral: string of numbers (e.g. "132")
CmdCount :: Word -> CommandOption

-- | Command handles a bang
--   
--   Stringliteral: "!"
CmdBang :: CommandOption

-- | Specification of a range that acommand can operate on.
data RangeSpecification

-- | The line the cursor is at when the command is invoked.
CurrentLine :: RangeSpecification

-- | Let the command operate on every line of the file.
WholeFile :: RangeSpecification

-- | Let the command operate on each line in the given range.
RangeCount :: Int -> RangeSpecification

-- | You 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.
data CommandArguments
CommandArguments :: Maybe Bool -> Maybe (Int, Int) -> Maybe Int -> Maybe String -> CommandArguments

-- | <a>Nothing</a> means that the function was not defined to handle a
--   bang, otherwise it means that the bang was passed (<tt><a>Just</a>
--   <a>True</a></tt>) or that it was not passed when called
--   (<tt><a>Just</a> <a>False</a></tt>).
[bang] :: CommandArguments -> Maybe Bool

-- | Range passed from neovim. Only set if <a>CmdRange</a> was used in the
--   export declaration of the command.
--   
--   Example:
--   
--   <ul>
--   <li><pre>Just (1,12)</pre></li>
--   </ul>
[range] :: CommandArguments -> Maybe (Int, Int)

-- | Count passed by neovim. Only set if <a>CmdCount</a> was used in the
--   export declaration of the command.
[count] :: CommandArguments -> Maybe Int

-- | Register that the command can/should/must use.
[register] :: CommandArguments -> Maybe String

-- | Options that can be used to register an autocmd. See <tt>:h
--   :autocmd</tt> or any referenced neovim help-page from the fields of
--   this data type.
data AutocmdOptions
AutocmdOptions :: String -> Bool -> Maybe String -> AutocmdOptions

-- | Pattern to match on. (default: "*")
[acmdPattern] :: AutocmdOptions -> String

-- | Nested autocmd. (default: False)
--   
--   See <tt>:h autocmd-nested</tt>
[acmdNested] :: AutocmdOptions -> Bool

-- | Group in which the autocmd should be registered.
[acmdGroup] :: AutocmdOptions -> Maybe String

-- | 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. .
--   
--   Note that the function you pass must be fully applied.
addAutocmd :: ByteString -> AutocmdOptions -> (Neovim env ()) -> Neovim env (Maybe (Either (Neovim anyEnv ()) ReleaseKey))

-- | Retrieves the monad environment.
ask :: MonadReader r m => m r

-- | Retrieves a function of the current environment.
asks :: MonadReader r m => (r -> a) -> m a

-- | Wait for the result of the STM action.
--   
--   This action possibly blocks as it is an alias for <tt> ioSTM -&gt;
--   ioSTM &gt;&gt;= liftIO . atomically</tt>.
wait :: Neovim env (STM result) -> Neovim env result

-- | Variant of <a>wait</a> that discards the result.
wait' :: Neovim env (STM result) -> Neovim env ()

-- | Wait for the result of the <a>STM</a> action and call <tt><a>err</a> .
--   (loc++) . show</tt> if the action returned an error.
waitErr :: String -> Neovim env (STM (Either NeovimException result)) -> Neovim env result

-- | <a>waitErr</a> that discards the result.
waitErr' :: String -> Neovim env (STM (Either NeovimException result)) -> Neovim env ()

-- | <tt><a>throw</a></tt> specialized to a <a>Pretty</a> value.
err :: Doc AnsiStyle -> Neovim env a
errOnInvalidResult :: (NvimObject o) => Neovim env (Either NeovimException Object) -> Neovim env o

-- | Exceptions specific to <i>nvim-hs</i>.
data NeovimException

-- | Simply error message that is passed to neovim. It should currently
--   only contain one line of text.
ErrorMessage :: (Doc AnsiStyle) -> NeovimException

-- | Error that can be returned by a remote API call. A call of
--   <tt>fromObject</tt> on this value could be converted to a value of
--   <tt>NeovimExceptionGen</tt>.
ErrorResult :: Object -> NeovimException

-- | Lift a computation from the <a>IO</a> monad.
liftIO :: MonadIO m => forall a. () => IO a -> m a

-- | Execute the given action with a changed set of environment variables
--   and restore the original state of the environment afterwards.
withCustomEnvironment :: (Traversable t, MonadUnliftIO m) => t (String, Maybe String) -> m c -> m c

-- | <a>when</a> with a monadic predicate.
whenM :: (Monad m) => m Bool -> m () -> m ()

-- | <a>unless</a> with a monadic predicate.
unlessM :: (Monad m) => m Bool -> m () -> m ()

-- | Convert a <a>Doc</a>-ument to a messagepack <a>Object</a>. This is
--   more a convenience method to transport error message from and to
--   neovim. It generally does not hold that 'docToObject . docFromObject'
--   = <a>id</a>.
docToObject :: Doc AnsiStyle -> Object

-- | See <a>docToObject</a>.
docFromObject :: Object -> Either (Doc AnsiStyle) (Doc AnsiStyle)

-- | The abstract data type <tt><a>Doc</a> ann</tt> represents pretty
--   documents that have been annotated with data of type <tt>ann</tt>.
--   
--   More specifically, a value of type <tt><a>Doc</a></tt> represents a
--   non-empty set of possible layouts of a document. The layout functions
--   select one of these possibilities, taking into account things like the
--   width of the output document.
--   
--   The annotation is an arbitrary piece of data associated with (part of)
--   a document. Annotations may be used by the rendering backends in order
--   to display output differently, such as
--   
--   <ul>
--   <li>color information (e.g. when rendering to the terminal)</li>
--   <li>mouseover text (e.g. when rendering to rich HTML)</li>
--   <li>whether to show something or not (to allow simple or detailed
--   versions)</li>
--   </ul>
--   
--   The simplest way to display a <a>Doc</a> is via the <a>Show</a> class.
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn (show (vsep ["hello", "world"]))
--   hello
--   world
--   </pre>
data Doc ann :: * -> *

-- | Render the annotated document in a certain style. Styles not set in
--   the annotation will use the style of the surrounding document, or the
--   terminal’s default if none has been set yet.
--   
--   <pre>
--   style = <a>color</a> <a>Green</a> <a>&lt;&gt;</a> <a>bold</a>
--   styledDoc = <a>annotate</a> style "hello world"
--   </pre>
data AnsiStyle :: *

-- | Overloaded conversion to <a>Doc</a>.
--   
--   Laws:
--   
--   <ol>
--   <li>output should be pretty. :-)</li>
--   </ol>
class Pretty a

-- | <pre>
--   &gt;&gt;&gt; pretty 1 &lt;+&gt; pretty "hello" &lt;+&gt; pretty 1.234
--   1 hello 1.234
--   </pre>
pretty :: Pretty a => a -> Doc ann

-- | <tt><a>prettyList</a></tt> is only used to define the <tt>instance
--   <a>Pretty</a> a =&gt; <a>Pretty</a> [a]</tt>. In normal circumstances
--   only the <tt><a>pretty</a></tt> function is used.
--   
--   <pre>
--   &gt;&gt;&gt; prettyList [1, 23, 456]
--   [1, 23, 456]
--   </pre>
prettyList :: Pretty a => [a] -> Doc ann

-- | <tt>(<a>putDoc</a> doc)</tt> prettyprints document <tt>doc</tt> to
--   standard output using <a>defaultLayoutOptions</a>.
--   
--   <pre>
--   &gt;&gt;&gt; putDoc ("hello" &lt;+&gt; "world")
--   hello world
--   </pre>
--   
--   <pre>
--   <a>putDoc</a> = <a>hPutDoc</a> <a>stdout</a>
--   </pre>
putDoc :: Doc AnsiStyle -> IO ()
exceptionToDoc :: NeovimException -> Doc AnsiStyle

-- | Priorities are used to define how important a log message is. Users
--   can filter log messages based on priorities.
--   
--   These have their roots on the traditional syslog system. The standard
--   definitions are given below, but you are free to interpret them
--   however you like. They are listed here in ascending importance order.
data Priority :: *

-- | Debug messages
DEBUG :: Priority

-- | Information
INFO :: Priority

-- | Normal runtime conditions
NOTICE :: Priority

-- | General Warnings
WARNING :: Priority

-- | General Errors
ERROR :: Priority

-- | Severe situations
CRITICAL :: Priority

-- | Take immediate action
ALERT :: Priority

-- | System is unusable
EMERGENCY :: Priority


module Neovim.Test

-- | Run the given <a>Neovim</a> action according to the given parameters.
--   The embedded neovim instance is started without a config (i.e. it is
--   passed <tt>-u NONE</tt>).
--   
--   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
--   <a>Neovim.API.String</a>.
testWithEmbeddedNeovim :: Maybe FilePath -> Seconds -> env -> Neovim env a -> IO ()

-- | Type synonym for <a>Word</a>.
newtype Seconds
Seconds :: Word -> Seconds


module Neovim.Debug

-- | Run a <a>Neovim</a> function.
--   
--   This function connects to the socket pointed to by the environment
--   variable <tt>$NVIM_LISTEN_ADDRESS</tt> and executes the command. It
--   does not register itself as a real plugin provider, you can simply
--   call neovim-functions from the module <a>Neovim.API.String</a> this
--   way.
--   
--   Tip: If you run a terminal inside a neovim instance, then this
--   variable is automatically set.
debug :: env -> Neovim env a -> IO (Either (Doc AnsiStyle) a)

-- | Run a <tt>Neovim'</tt> function.
--   
--   <pre>
--   debug' a = fmap fst <a>$</a> debug () () a
--   </pre>
--   
--   See documentation for <a>debug</a>.
debug' :: Neovim () a -> IO (Either (Doc AnsiStyle) a)

-- | This function is intended to be run _once_ in a ghci session that to
--   give a REPL based workflow when developing a plugin.
--   
--   Note that the dyre-based reload mechanisms, i.e. the
--   <a>Neovim.Plugin.ConfigHelper</a> 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:
--   
--   <pre>
--   λ <a>Right</a> (tids, cfg) &lt;- <a>develMain</a> <a>Nothing</a>
--   
--   λ <a>runNeovim'</a> cfg $ vim_call_function "getqflist" []
--   <a>Right</a> (<a>Right</a> (<a>ObjectArray</a> []))
--   
--   λ :r
--   
--   λ <a>Right</a> (tids, cfg) &lt;- <a>develMain</a> <a>Nothing</a>
--   </pre>
develMain :: Maybe NeovimConfig -> IO (Either (Doc AnsiStyle) [Async ()])

-- | Quit a previously started plugin provider.
quitDevelMain :: Config env -> IO ()

-- | Restart the development plugin provider.
restartDevelMain :: Config RPCConfig -> Maybe NeovimConfig -> IO (Either (Doc AnsiStyle) [Async ()])

-- | Print the global function map to the console.
printGlobalFunctionMap :: Config env -> IO ()

-- | Initialize a <a>Neovim</a> context by supplying an
--   <tt>InternalEnvironment</tt>.
runNeovim :: NFData a => Config env -> Neovim env a -> IO (Either (Doc AnsiStyle) a)

-- | Convenience function to run a stateless <a>Neovim</a> function.
runNeovim' :: NFData a => Config env -> Neovim () a -> IO (Either (Doc AnsiStyle) a)