Vcaml (p.vcaml.v0.16.0.doc.vcaml.Vcaml)

module Unshadow_buffer := Buffer

module Unshadow_command := Command

Sourcemodule Api_version = Nvim_internal.Api_version

Sourcemodule Buffer = Unshadow_buffer

Sourcemodule Channel_info : sig ... end

Sourcemodule Client_info : sig ... end

Client_info is present for every remote, ui, embedder, host, or plugin attached to neovim.

Sourcemodule Color : sig ... end

Sourcemodule Command = Unshadow_command

Sourcemodule Error_type = Nvim_internal.Error_type

Sourcemodule Highlighted_text : sig ... end

Sourcemodule Keymap : sig ... end

Sourcemodule Mark : sig ... end

Sourcemodule Mode : sig ... end

Sourcemodule Namespace : sig ... end

Sourcemodule Nvim : sig ... end

Sourcemodule Position : sig ... end

Sourcemodule Tabpage : sig ... end

Sourcemodule Type = Nvim_internal.Phantom

Sourcemodule Ui : sig ... end

Sourcemodule Vcaml_error : sig ... end

Sourcemodule Window : sig ... end

Sourceval api_version : Api_version.t

API version for which this library is built (not the same as the Neovim version).

Sourceval pp : Core.Formatter.t -> Msgpack.t -> unit

Msgpack.pp with support for Neovim Msgpack extensions.

Sourcemodule Nvim_version : sig ... end

Sourcemodule Client : sig ... end

Sourcemodule Api_call : sig ... end

A 'a Api_call.t is a thunked call to neovim returning a Msgpack-encoded 'a. No RPC traffic is generated until an Api_call.t is invoked via run or run_join.

Source

val run : 
  Core.Source_code_position.t ->
  [ `connected ] Client.t ->
  'a Api_call.t ->
  'a Async.Deferred.Or_error.t

Source

val run_join : 
  Core.Source_code_position.t ->
  [ `connected ] Client.t ->
  'a Api_call.Or_error.t ->
  'a Async.Deferred.Or_error.t

Sourcemodule Defun : sig ... end

Source

val wrap_viml_function : 
  type_:('fn, 'leftmost, 'out) Defun.Vim.t ->
  function_name:string ->
  'fn

Given the name of a function available in Vimscript (VimL) along with its arity (see Defun.Vim), return a regularly-typed OCaml function that calls said function.

This is intended for client authors to delegate work back to Neovim, possibly to call an existing Vimscript function. Before reaching for this function, please check the functions available in Nvim, Buffer, Window and Tabpage to see that the functionality you intend to wrap isn't directly exposed in the API.

Source

val register_request_blocking : 
  _ Client.t ->
  name:string ->
  type_:('fn, 'leftmost) Defun.Ocaml.Sync.t ->
  f:
    (keyboard_interrupted:unit Async.Deferred.t ->
      client:[ `connected ] Client.t ->
      'fn) ->
  unit

register_request_blocking and register_request_async register functions that can be called from Neovim via rpcrequest and rpcnotify respectively. This is achieved by adding a listener to the Neovim msgpack_rpc bus.

A blocking request will block Neovim from processing user input or communication over other channels until a response is returned. Neovim will continue to process calls sent over the same channel while a blocking request is in flight, which means nested calls are supported.

When the user presses Ctrl-C to interrupt a blocking call, keyboard_interrupted will be determined. Use that to run any necessary cleanup. If you call back into Neovim during the blocking RPC, consider whether a keyboard interrupt should prevent those calls from being run.

An async request will enqueue logic on Neovim's event loop instead of blocking. Importantly, the state of the editor may have changed between the time the async request was made and the time Neovim process any of its logic.

Source

val register_request_async : 
  _ Client.t ->
  name:string ->
  type_:'fn Defun.Ocaml.Async.t ->
  f:(client:[ `connected ] Client.t -> 'fn) ->
  unit

Sourcemodule Expert : sig ... end

Sourcemodule Private : sig ... end