package janestreet_csv

You can search for identifiers within the package.

in-package search v0.2.0

janestreet_csv.csv_tool_lib
- Csv_tool_lib
  - Change_separator
  - Csv_common
    
    Or_file
  - Csv_grid
  - Csv_param
    
    Let_syntax
    
    Let_syntax
  - Csv_param_intf
    
    Csv_param
    
    Let_syntax
    
    Let_syntax
    
    Open_on_rhs_intf
    
    S
  - Csv_shape
  - Csv_sort
    
    Order
    
    Sort_column
    
    Sort_type
  - Csv_sum
  - Csv_transpose
  - Cut
  - Diff
  - Grep
    
    Target_fields
  - Id
  - Join
    
    Row
  - Key_specifier
  - Mapped_csv
  - Merge
  - Of_sexp
  - Pretty
  - Split_csv
  - Sum_group
  - To_ascii_table
  - To_html_table
  - Validate

Legend:
Library
Module
Module type
Parameter
Class
Class type

include Csv_param_intf.Csv_param

module Open_on_rhs_intf = Csv_param_intf.Open_on_rhs_intf

include Open_on_rhs_intf.S

include module type of struct include Async.Command.Param end

include sig ... end

module type S = Async.Command.Param.S

type 'a t = 'a Command.Param.t

val return : 'a -> 'a t

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

val both : 'a t -> 'b t -> ('a * 'b) t

val (<*>) : ('a -> 'b) t -> 'a t -> 'b t

val (<*) : 'a t -> unit t -> 'a t

val (*>) : unit t -> 'a t -> 'a t

val (>>|) : 'a t -> ('a -> 'b) -> 'b t

val apply : ('a -> 'b) t -> 'a t -> 'b t

val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t

val map3 : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t

val all : 'a t list -> 'a list t

val all_unit : unit t list -> unit t

module Applicative_infix = Async.Command.Param.Applicative_infix

val help : Base.string Base.Lazy.t t

val path : Base.string Base.list t

val args : Base.string Base.list t

val flag : 
  ?aliases:Base.string Base.list ->
  ?full_flag_required:Base.unit ->
  Base.string ->
  'a Command.Flag.t ->
  doc:Base.string ->
  'a t

val flag_optional_with_default_doc : 
  ?aliases:Base.string Base.list ->
  ?full_flag_required:Base.unit ->
  Base.string ->
  'a Command.Arg_type.t ->
  ('a -> Base.Sexp.t) ->
  default:'a ->
  doc:Base.string ->
  'a t

val anon : 'a Command.Anons.t -> 'a t

val escape_anon : 
  final_anon:'a Command.Anons.t ->
  ('a * Base.string Base.list) t

module If_nothing_chosen = Async.Command.Param.If_nothing_chosen

val choose_one : 
  'a Base.option t Base.list ->
  if_nothing_chosen:('a, 'b) If_nothing_chosen.t ->
  'b t

val choose_one_non_optional : 
  'a t Base.list ->
  if_nothing_chosen:('a, 'b) If_nothing_chosen.t ->
  'b t

val and_arg_names : 'a t -> ('a * Base.string Base.list) t

val and_arg_name : 'a t -> ('a * Base.string) t

val arg_names : 'a t -> Base.string Base.list

val optional_to_required : 'a Base.option t -> 'a t

val required : 'a Command.Arg_type.t -> 'a Command.Flag.t

val optional : 'a Command.Arg_type.t -> 'a Base.option Command.Flag.t

val optional_with_default : 'a -> 'a Command.Arg_type.t -> 'a Command.Flag.t

val listed : 'a Command.Arg_type.t -> 'a Base.list Command.Flag.t

val one_or_more_as_pair : 
  'a Command.Arg_type.t ->
  ('a * 'a Base.list) Command.Flag.t

val one_or_more_as_list : 'a Command.Arg_type.t -> 'a Base.list Command.Flag.t

val no_arg : Base.bool Command.Flag.t

val no_arg_register : 
  key:'a Univ_map.With_default.Key.t ->
  value:'a ->
  Base.bool Command.Flag.t

val no_arg_some : 'a -> 'a Base.option Command.Flag.t

val no_arg_required : 'a -> 'a Command.Flag.t

val no_arg_abort : 
  exit:(Base.unit -> Base.Nothing.t) ->
  Base.unit Command.Flag.t

val escape : Base.string Base.list Base.option Command.Flag.t

val escape_with_autocomplete : 
  complete:Command.Auto_complete.For_escape.t ->
  Base.string Base.list Base.option Command.Flag.t

val map_flag : 'a Command.Flag.t -> f:('a -> 'b) -> 'b Command.Flag.t

val (%:) : Base.string -> 'a Command.Arg_type.t -> 'a Command.Anons.t

val sequence : 'a Command.Anons.t -> 'a Base.list Command.Anons.t

val non_empty_sequence_as_pair : 
  'a Command.Anons.t ->
  ('a * 'a Base.list) Command.Anons.t

val non_empty_sequence_as_list : 
  'a Command.Anons.t ->
  'a Base.list Command.Anons.t

val maybe : 'a Command.Anons.t -> 'a Base.option Command.Anons.t

val maybe_with_default : 'a -> 'a Command.Anons.t -> 'a Command.Anons.t

val t2 : 'a Command.Anons.t -> 'b Command.Anons.t -> ('a * 'b) Command.Anons.t

val t3 : 
  'a Command.Anons.t ->
  'b Command.Anons.t ->
  'c Command.Anons.t ->
  ('a * 'b * 'c) Command.Anons.t

val t4 : 
  'a Command.Anons.t ->
  'b Command.Anons.t ->
  'c Command.Anons.t ->
  'd Command.Anons.t ->
  ('a * 'b * 'c * 'd) Command.Anons.t

val map_anons : 'a Command.Anons.t -> f:('a -> 'b) -> 'b Command.Anons.t

val parse : 'a t -> Base.string Base.list -> 'a Base.Or_error.t

module Arg_type = Async.Command.Param.Arg_type

include module type of struct include Arg_type.Export end

Values to include in other namespaces.

val string : Base.string Command.Arg_type.t

val int : Base.int Command.Arg_type.t

Beware that an anonymous argument of type int cannot be specified as negative, as it is ambiguous whether -1 is a negative number or a flag. (The same applies to float, time_span, etc.) You can use the special built-in "-anon" flag to force a string starting with a hyphen to be interpreted as an anonymous argument rather than as a flag, or you can just make it a parameter to a flag to avoid the issue.

val char : Base.char Command.Arg_type.t

val float : Base.float Command.Arg_type.t

val bool : Base.bool Command.Arg_type.t

val sexp : Base.Sexp.t Command.Arg_type.t

val sexp_conv : 
  ?complete:Command.Auto_complete.t ->
  (Base.Sexp.t -> 'a) ->
  'a Command.Arg_type.t

val date : Core.Date.t Command.Arg_type.t

val percent : Core.Percent.t Command.Arg_type.t

val host_and_port : Core.Host_and_port.t Command.Arg_type.t

val file_stdin_anon : Csv_common.Or_file.t t

val file_stdin_flag : Csv_common.Or_file.t t

val files : string list t

val reverse : bool t

val reverse_fields : string list t

val field : string t

val field' : aliases:string list -> string t

val time_field : string t

val start_time : Core.Time_float.t t

val stop_time : Core.Time_float.t t

val grid_step : Core.Time_float.Span.t t

val max_width : int option t

val prefer_split_on_spaces : bool t

val regexp_arg : Re2.t Arg_type.t

val regexp : Re2.t t

val invert : bool t

val skip_lines : int option t

val sep_arg : char Arg_type.t

val sep : char t

val key_specifier : string t

val no_header : bool t

val space : int t

val suppress_header : bool t

val fields_gen : doc:string -> string list t

val fields : string list t

val fields_backward_compat : string list t

val pop_fields : string list t

val exclude_fields : bool t

val table_attrs : (string * string option) list t

val th_attrs : (string * string option) list t

val tr_attrs : (string * string option) list t

val td_attrs : (string * string option) list t

val border : bool t

include Core.Applicative.Let_syntax
  with type 'a t := 'a Async.Command.Param.t
  with module Open_on_rhs_intf := Open_on_rhs_intf

module Let_syntax : sig ... end