package lsp

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Basic combinators
Break hints
Boxes
Common convenience functions
Operators
Rendering

package lsp

lsp
- Lsp
lsp.fiber
- Fiber
  - Ivar
  - Mutex
  - Mvar
  - O
  - Sequence
  - Throttle
  - Var
lsp.fiber_unix
- Fiber_unix
  - Fiber_detached
  - Fiber_stream
    
    In
    
    Out
  - Private
    
    Removable_queue
  - Scheduler
lsp.stdune
- Stdune
  - Ansi_color
    
    Style
  - Appendable_list
  - Applicative
    
    Id
    
    O
    
    Make
    
    A
    
    O
  - Applicative_intf
    
    S1
    
    O
    
    S1_base
  - Array
  - Bin
  - Bool
  - Bytes
  - Char
  - Code_error
  - Comparable
    
    Make
    
    Key
    
    Map
    
    Multi
    
    Set
  - Comparable_intf
    
    S
    
    Key
    
    Map
    
    Multi
    
    Set
  - Comparator
    
    OPS
    
    Operators
    
    X
    
    S
  - Console
    
    Backend
    
    S
    
    Status_line
  - Csexp
    
    Input
    
    Monad
    
    Make_parser
    
    Input
    
    Monad
    
    Parser
    
    Lexer
    
    Stack
  - Daemonize
  - Digest
    
    Set
  - Dyn
    
    Encoder
  - Either
  - Env
    
    Map
    
    Multi
    
    Var
    
    Set
  - Exn
  - Exn_with_backtrace
  - Fcntl
  - Fdecl
  - Filename
  - Float
  - Fun
  - Hashtbl
    
    Make
    
    Key
    
    S
  - Id
    
    Make
    
    Map
    
    Multi
    
    Set
    
    S
    
    Map
    
    Multi
    
    Set
  - Int
    
    Infix
    
    Map
    
    Multi
    
    Set
  - Interned
    
    Make
    
    Map
    
    Multi
    
    R
    
    Set
    
    Table
    
    No_interning
    
    Map
    
    Multi
    
    R
    
    Set
    
    Table
    
    Settings
  - Interned_intf
    
    S
    
    Map
    
    Multi
    
    Set
    
    Table
  - Io
    
    String_path
  - Lexbuf
  - List
  - Loc
    
    Map
    
    Multi
  - Lock_file
  - Map
    
    Key
    
    Make
    
    Key
    
    Multi
    
    S
    
    Multi
  - Monad
    
    Id
    
    O
    
    Make
    
    M
    
    O
  - Monad_intf
    
    S1
    
    O
    
    S1_base
  - Nothing
  - Option
    
    List
    
    O
  - Or_exn
    
    O
  - Ordering
  - Path
    
    Build
    
    Kind
    
    L
    
    Map
    
    Multi
    
    Set
    
    Table
    
    External
    
    Map
    
    Multi
    
    Set
    
    Table
    
    L
    
    Local
    
    L
    
    Map
    
    Multi
    
    Set
    
    Table
    
    Local_gen
    
    Fix_root
    
    Map
    
    Multi
    
    Root
    
    Set
    
    Table
    
    L
    
    Map
    
    Multi
    
    Set
    
    Source
    
    L
    
    Map
    
    Multi
    
    Set
    
    Table
    
    Table
    
    Unspecified
  - Pid
  - Poly
  - Pp
    
    O
  - Proc
  - Queue
  - Result
    
    List
    
    O
    
    Option
  - Scanf
  - Set
    
    Make
    
    Key
    
    M
    
    Multi
    
    S
  - Sexp
  - Signal
  - Spawn
    
    Env
  - Staged
  - String
    
    Map
    
    Multi
    
    Set
    
    Table
  - Sys
  - Table
    
    Key
  - Top_closure
    
    Int
    
    Make
    
    Keys
    
    Monad
    
    O
    
    String
  - Top_closure_intf
    
    Keys
    
    S
  - Tuple
    
    T2
    
    T3
  - Type_eq
    
    Id
  - Unit
  - Univ_map
    
    Key
  - User_error
  - User_message
    
    Print_config
    
    Style
  - User_warning

Legend:
Library
Module
Module type
Parameter
Class
Class type

Pretty printers

type +'tag t

A document that is not yet rendered. The argument is the type of tags in the document. For instance tags might be used for styles.

Basic combinators

val nop : _ t

A pretty printer that prints nothing

val seq : 'a t -> 'a t -> 'a t

seq x y prints x and then y

val concat : ?sep:'a t -> 'a t list -> 'a t

concat ?sep l prints elements in l separated by sep. sep defaults to nop.

val concat_map : ?sep:'a t -> 'b list -> f:('b -> 'a t) -> 'a t

Convenience function for List.map followed by concat

val concat_mapi : ?sep:'a t -> 'b list -> f:(int -> 'b -> 'a t) -> 'a t

val verbatim : string -> _ t

An indivisible block of text

val char : char -> _ t

A single character

val text : string -> _ t

Print a bunch of text. The line may be broken at any spaces in the text.

val textf : ('a, unit, string, _ t) Stdlib.format4 -> 'a

Same as text but take a format string as argument.

val tag : 'a -> 'a t -> 'a t

tag x t Tag the material printed by t with x

Break hints

val space : _ t

Either a newline or a space, depending on whether the line is broken at this point.

val cut : _ t

Either a newline or nothing, depending on whether the line is broken at this point.

val break : nspaces:int -> shift:int -> _ t

Either a newline or nspaces spaces. If it is a newline, shift is added to the indentation level.

val newline : _ t

Force a newline to be printed

val map_tags : 'a t -> f:('a -> 'b) -> 'b t

Convert tags in a documents

val filter_map_tags : 'a t -> f:('a -> 'b option) -> 'b t

Boxes

Boxes are the basic components to control the layout of the text. Break hints such as space and cut may cause the line to be broken, depending on the splitting rules. Whenever a line is split, the rest of the material printed in the box is indented with indent.

val box : ?indent:int -> 'a t -> 'a t

Try to put as much as possible on each line. Additionally, a break hint always break the line if the breaking would reduce the indentation level (break with negative shift value).

val vbox : ?indent:int -> 'a t -> 'a t

Always break the line when encountering a break hint.

val hbox : 'a t -> 'a t

Print everything on one line, no matter what

val hvbox : ?indent:int -> 'a t -> 'a t

If possible, print everything on one line. Otherwise, behave as a vbox

val hovbox : ?indent:int -> 'a t -> 'a t

Try to put as much as possible on each line.

Common convenience functions

val enumerate : 'a list -> f:('a -> 'b t) -> 'b t

enumerate l ~f produces an enumeration of the form:

- item1 - item2 - item3 ...

val chain : 'a list -> f:('a -> 'b t) -> 'b t

chain l ~f is used to print a succession of items that follow each other. It produces an output of this form:

item1 -> item2 -> item3 ...

Operators

module O : sig ... end

Rendering

val render : 
  Stdlib.Format.formatter ->
  'a t ->
  tag_handler:(Stdlib.Format.formatter -> 'a -> 'a t -> unit) ->
  unit

Render a document to a classic formatter

val render_ignore_tags : Stdlib.Format.formatter -> 'a t -> unit