Quick_print (quick_print.Quick

val strings_list :
              ?prefix:string ->
              string list
                ->
              unit

strings_list ~prefix list prints the list of strings to the standard output with the prefix.

val string_list_list :
              ?prefix:string ->
              string list list
                ->
              unit

string_list_list ?prefix list prints a list of string lists to standard output. Each inner list is formatted as a bracketed, semicolon-separated sequence of strings (e.g., "one; two; three"). The inner lists themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the list.

val string_array_list :
              ?prefix:string ->
              string array list
                ->
              unit

string_array_list ?prefix list prints a list of string arrays to standard output. Each inner array is formatted as a bracketed, semicolon-separated sequence of strings enclosed by array brackets (e.g., "|one; two; three|"). The inner arrays themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the list.

val string_array_array :
              ?prefix:string ->
              string array array
                ->
              unit

string_array_array ?prefix arr prints an array of string arrays to standard output. Each inner array is formatted as a bracketed, semicolon-separated sequence of strings enclosed by array brackets (e.g., "|one; two; three|"). The inner arrays themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the array.

val chars_list :
              ?prefix:string ->
              char list
                ->
              unit

chars_list ~prefix list prints the list of chars to the standard output with the prefix.

val char_list_list :
              ?prefix:string ->
              char list list
                ->
              unit

char_list_list ?prefix list prints a list of char lists to standard output. Each inner list is formatted as a bracketed, semicolon-separated sequence of characters (e.g., "a; b; c"). The inner lists themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the list.

val char_array_list :
              ?prefix:string ->
              char array list
                ->
              unit

char_array_list ?prefix list prints a list of character arrays to standard output. Each inner array is formatted as a bracketed, semicolon-separated sequence of characters enclosed by array brackets (e.g., "|'a'; 'b'; 'c'|"). The inner arrays themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the list.

val char_array_array :
              ?prefix:string ->
              char array array
                ->
              unit

char_array_array ?prefix arr prints an array of char arrays to standard output. Each inner array is formatted as a bracketed, semicolon-separated sequence of chars enclosed by array brackets (e.g., "|a; b; c|"). The inner arrays themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the array.

val int_list :
              ?prefix:string ->
              int list
                ->
              unit

int_list ~prefix list prints the list of integers to the standard output with the prefix.

val int_list_list :
              ?prefix:string ->
              int list list
                ->
              unit

int_list_list ?prefix list prints a list of int lists to standard output. Each inner list is formatted as a bracketed, semicolon-separated sequence of integers (e.g., "1; 2; 3"). The inner lists themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the list.

val int_array_list :
              ?prefix:string ->
              int array list
                ->
              unit

int_array_list ?prefix list prints a list of integer arrays to standard output. Each inner array is formatted as a bracketed, semicolon-separated sequence of integers enclosed by array brackets (e.g., "|1; 2; 3|"). The inner arrays themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the list.

val int_array_array :
              ?prefix:string ->
              int array array
                ->
              unit

int_array_array ?prefix arr prints an array of integer arrays to standard output. Each inner array is formatted as a bracketed, semicolon-separated sequence of integers enclosed by array brackets (e.g., "|1; 2; 3|"). The inner arrays themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the array.

val float_list :
              ?prefix:string ->
              ?precision:int ->
              float list
                ->
              unit

float_list ~prefix ~precision list prints the list of floats to the standard output with a given precision and with the prefix.

val float_list_list :
              ?prefix:string ->
              ?precision:int ->
              float list list
                ->
              unit

float_list_list ?prefix ?precision list prints a list of float lists to standard output. Each inner list is formatted as a bracketed, semicolon-separated sequence of floats (e.g., "1.23; 4.56; 7.89"), with precision decimal places. The inner lists themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the list. The optional precision argument (defaulting to 2 if omitted) specifies the number of decimal places for the floating-point values.

val float_array_list :
              ?prefix:string ->
              ?precision:int ->
              float array list
                ->
              unit

float_array_list ?prefix ?precision list prints a list of float arrays to standard output. Each inner array is formatted as a bracketed, semicolon-separated sequence of floats enclosed by array brackets (e.g., "|1.00; 2.00; 3.00|"). The inner arrays themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the list. The optional precision argument (defaulting to 2, if omitted) determines the number of decimal places for each float.

val float_array_array :
              ?prefix:string ->
              ?precision:int ->
              float array array
                ->
              unit

float_array_array ?prefix ?precision arr prints an array of float arrays to standard output. Each inner array is formatted as a bracketed, semicolon-separated sequence of floats enclosed by array brackets (e.g., "|1.00; 2.00; 3.00|"). The inner arrays themselves are also separated by semicolons and spaces. The optional prefix argument (defaulting to an empty string, if omitted) is printed before the array. The optional precision argument specifies the number of decimal places for the floats (defaulting to 2 if omitted).

val string_string_tuple_list :
              ?prefix:string ->
              (string * string) list
                ->
              unit

string_string_tuple_list ?prefix list prints a list of (string, string) tuples to standard output. Each tuple is formatted as (string1, string2). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val string_char_tuple_list :
              ?prefix:string ->
              (string * char) list
                ->
              unit

string_char_tuple_list ?prefix list prints a list of (string, char) tuples to standard output. Each tuple is formatted as (string, c). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val string_int_tuple_list :
              ?prefix:string ->
              (string * int) list
                ->
              unit

string_int_tuple_list ?prefix list prints a list of (string, int) tuples to standard output. Each tuple is formatted as (string, n). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val string_float_tuple_list :
              ?prefix:string ->
              ?precision:int ->
              (string * float) list
                ->
              unit

string_float_tuple_list ?prefix ?precision list prints a list of (string, float) tuples to standard output. Each tuple is formatted as (string, f), where f has precision decimal places. Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list. The optional precision argument (defaulting to 2 if omitted) sets the number of decimal places for floats.

val char_string_tuple_list :
              ?prefix:string ->
              (char * string) list
                ->
              unit

char_string_tuple_list ?prefix list prints a list of (char, string) tuples to standard output. Each tuple is formatted as (c, string). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val char_char_tuple_list :
              ?prefix:string ->
              (char * char) list
                ->
              unit

char_char_tuple_list ?prefix list prints a list of (char, char) tuples to standard output. Each tuple is formatted as (c1, c2). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val char_int_tuple_list :
              ?prefix:string ->
              (char * int) list
                ->
              unit

char_int_tuple_list ?prefix list prints a list of (char, int) tuples to standard output. Each tuple is formatted as (c, n). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val char_float_tuple_list :
              ?prefix:string ->
              ?precision:int ->
              (char * float) list
                ->
              unit

char_float_tuple_list ?prefix ?precision list prints a list of (char, float) tuples on standard output. Each tuple is formatted as (c, f.##), where f has precision decimal places. Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) will be printed before the list. The optional precision argument (defaulting to 2 if omitted) sets the number of decimal places for floats.

val int_string_tuple_list :
              ?prefix:string ->
              (int * string) list
                ->
              unit

int_string_tuple_list ?prefix list prints a list of (int, string) tuples to standard output. Each tuple is formatted as (n, string). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val int_char_tuple_list :
              ?prefix:string ->
              (int * char) list
                ->
              unit

int_char_tuple_list ?prefix list prints a list of (int, char) tuples to standard output. Each tuple is formatted as (n, c). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val int_int_tuple_list :
              ?prefix:string ->
              (int * int) list
                ->
              unit

int_int_tuple_list ?prefix list prints a list of (int, int) tuples to standard output. Each tuple is formatted as (n, m). Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list.

val int_float_tuple_list :
              ?prefix:string ->
              ?precision:int ->
              (int * float) list
                ->
              unit

int_float_tuple_list ?prefix ?precision list prints a list of (int, float) tuples to standard output. Each tuple is formatted as (n, f), where f is a float with precision decimal places. Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list. The optional precision argument (defaulting to 2 if omitted) sets the number of decimal places for float.

val float_string_tuple_list :
              ?prefix:string ->
              ?precision:int ->
              (float * string) list
                ->
              unit

float_string_tuple_list ?prefix ?precision list prints a list of (float, string) tuples to standard output. Each tuple is formatted as (f, string), where f is a float with precision decimal places. Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list. The optional precision argument (defaulting to 2 if omitted) sets the number of decimal places for the float.

val float_char_tuple_list :
              ?prefix:string ->
              ?precision:int ->
              (float * char) list
                ->
              unit

float_char_tuple_list ?prefix ?precision list prints a list of (float, char) tuples to standard output. Each tuple is formatted as (f, c), where f is a float with precision decimal places. Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list. The optional precision argument (defaulting to 2 if omitted) sets the number of decimal places for the float.

val float_int_tuple_list :
              ?prefix:string ->
              ?precision:int ->
              (float * int) list
                ->
              unit

float_int_tuple_list ?prefix ?precision list prints a list of (float, int) tuples to standard output. Each tuple is formatted as (f, n), where f is a float with precision decimal places. Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list. The optional precision argument (defaulting to 2 if omitted) sets the number of decimal places for the float.

val float_float_tuple_list :
              ?prefix:string ->
              ?precision:int ->
              (float * float) list
                ->
              unit

float_float_tuple_list ?prefix ?precision list prints a list of (float, float) tuples to standard output. Each tuple is formatted as (f1, f2), where f1 and f2 are floats with precision decimal places. Tuples are separated by a semicolon and a space. The optional prefix argument (defaulting to an empty string if omitted) is printed before the list. The optional precision argument (defaulting to 2 if omitted) sets the number of decimal places for the floats.

val strings_array :
              ?prefix:string ->
              string array
                ->
              unit

strings_array ~prefix arr converts the arr array to a list and prints it to the standard output with a given prefix.

val chars_array :
              ?prefix:string ->
              char array
                ->
              unit

chars_array ~prefix arr converts the arr array of characters to a list and prints it to the standard output with a given prefix.

val int_array :
              ?prefix:string ->
              int array
                ->
              unit

int_array ~prefix arr converts the arr array of integers to a list and prints it to the standard output with a given prefix.

val float_array :
              ?prefix:string ->
              ?precision:int ->
              float array
                ->
              unit

float_array ~prefix ~precision arr converts the arr array of floats to a list and prints it with the specified precision and prefix to the standard output.

val hashtable_int_string :
              ?prefix:string ->
              (int, string)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_string ~prefix ht prints the entries of a hashtable ht (with integer keys and string values) to the standard output, using the prefix. Each entry is represented as a tuple (key, value).

val hashtable_int_char :
              ?prefix:string ->
              (int, char)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_char ~prefix ht prints the entries of a hashtable ht (with integer keys and character values) to the standard output, using the prefix. Each entry is represented as a tuple (key, value).

val hashtable_int_int :
              ?prefix:string ->
              (int, int)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_int ~prefix ht prints the entries of a hashtable ht (with integer keys and integer values) to the standard output, using the prefix. Each entry is represented as a tuple (key, value).

val hashtable_int_float :
              ?prefix:string ->
              ?precision:int ->
              (int, float)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_float ~prefix ~precision ht prints the entries of a hashtable ht (with integer keys and floating point values) to the standard output, using the prefix. The floating point values are shown with the given precision. Each entry is represented as a tuple (key, value).

val hashtable_string_string :
              ?prefix:string ->
              (string, string)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_string_string ~prefix ht prints the entries of a hashtable ht (with string keys and string values) to the standard output, using the prefix. Each entry is represented as a tuple (key, value).

val hashtable_string_char :
              ?prefix:string ->
              (string, char)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_string_char ~prefix ht prints the entries of a hashtable ht (with string keys and character values) to the standard output, using the prefix. Each entry is represented as a tuple (key, value).

val hashtable_string_int :
              ?prefix:string ->
              (string, int)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_int ~prefix ht prints the entries of a hashtable ht (with string keys and integer values) to the standard output, using the prefix. Each entry is represented as a tuple (key, value).

val hashtable_string_float :
              ?prefix:string ->
              ?precision:int ->
              (string, float)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_float ~prefix ~precision ht prints the entries of a hashtable ht (with string keys and floating point values) to the standard output, using the prefix. The floating point values are shown with the given precision. Each entry is represented as a tuple (key, value).

val hashtable_int_string_list :
              ?prefix:string ->
              (int, string list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_string_list ~prefix ht prints the entries of a hashtable ht (with integer keys and list of strings) to the standard output, using the prefix. The strings in each list are joined with '; ' and enclosed in brackets .

val hashtable_int_char_list :
              ?prefix:string ->
              (int, char list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_char_list ~prefix ht prints the entries from the hashtable ht (with integer keys and list of chars) to the standard output, using the prefix. The characters in each list are joined with '; ' and enclosed in brackets .

val hashtable_int_int_list :
              ?prefix:string ->
              (int, int list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_int_list ~prefix ht prints the entries of hashtable ht (with integer keys and list of integers) to the standard output, using the prefix. The integers in each list are joined with '; ' and enclosed in brackets .

val hashtable_int_float_list :
              ?prefix:string ->
              ?precision:int ->
              (int, float list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_int_float_list ~prefix ~precision ht prints the entries of the hashtable ht (with integer keys and list of floats) to the standard output, using the prefix. Floating point numbers are formatted with the provided precision. The floats in each list are joined with '; ' and enclosed in brackets .

val hashtable_string_string_list :
              ?prefix:string ->
              (string, string list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_string_string_list ~prefix ht prints the entries of a hashtable ht (with string keys and list of strings) to the standard output, using the prefix. The strings in each list are joined with '; ' and enclosed in brackets .

val hashtable_string_char_list :
              ?prefix:string ->
              (string, char list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_string_char_list ~prefix ht prints the entries from the hashtable ht (with string keys and list of chars) to the standard output, using the prefix. The characters in each list are joined with '; ' and enclosed in brackets .

val hashtable_string_int_list :
              ?prefix:string ->
              (string, int list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_string_int_list ~prefix ht prints the entries of hashtable ht (with string keys and list of integers) to the standard output, using the prefix. The integers in each list are joined with '; ' and enclosed in brackets .

val hashtable_string_float_list :
              ?prefix:string ->
              ?precision:int ->
              (string, float list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_string_float_list ~prefix ~precision ht prints the entries of the hashtable ht (with string keys and list of floats) to the standard output, using the prefix. Floating point numbers are formatted with the provided precision. The floats in each list are joined with '; ' and enclosed in brackets .

val hashtable_char_string_list :
              ?prefix:string ->
              (char, string list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_char_string_list ~prefix ht prints the entries of a hashtable ht (with character keys and list of strings) to the standard output, using the prefix. The strings in each list are joined with '; ' and enclosed in brackets .

val hashtable_char_char_list :
              ?prefix:string ->
              (char, char list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_char_char_list ~prefix ht prints the entries from the hashtable ht (with char keys and list of chars) to the standard output, using the prefix. The characters in each list are joined with '; ' and enclosed in brackets .

val hashtable_char_int_list :
              ?prefix:string ->
              (char, int list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_char_int_list ~prefix ht prints the entries of hashtable ht (with character keys and list of integers) to the standard output, using the prefix. The integers in each list are joined with '; ' and enclosed in brackets .

val hashtable_char_float_list :
              ?prefix:string ->
              ?precision:int ->
              (char, float list)
                  Stdlib.Hashtbl.t
                ->
              unit

hashtable_char_float_list ~prefix ~precision ht prints the entries of the hashtable ht (with character keys and list of floats) to the standard output, using the prefix. Floating point numbers are formatted with the provided precision. The floats in each list are joined with '; ' and enclosed in brackets .

val tuple_strings_list_strings_list
              :
              ?prefix:string ->
              (string list * string list)
                ->
              unit

tuple_strings_list_strings_list ?prefix (list1, list2) prints the tuple of string lists (list1, list2) to the standard output. Each string from the lists is separated by a semicolon and a space "; ". The tuple is presented in this string format: "(list1, list2)".

val tuple_chars_list_chars_list :
              ?prefix:string ->
              (char list * char list)
                ->
              unit

tuple_chars_list_chars_list ?prefix (list1, list2) prints optional prefix and the tuple of character lists (list1, list2) to the standard output, with each character separated by a semicolon and a space "; ". The tuple is presented in this string format: "(list1, list2)".

val tuple_ints_list_ints_list :
              ?prefix:string ->
              (int list * int list)
                ->
              unit

tuple_ints_list_ints_list ?prefix (list1, list2) prints optional prefix and the tuple of integer lists (list1, list2) to the standard output, with each integer separated by a semicolon and a space "; ". The tuple is presented in this string format: "(list1, list2)".

val tuple_floats_list_floats_list :
              ?prefix:string ->
              ?precision:int ->
              (float list * float list)
                ->
              unit

tuple_floats_list_floats_list ?prefix ?precision (list1, list2) prints the optional prefix and the tuple of float lists (list1, list2) as a formatted string with each number separated by a semicolon and a space "; ". The precision parameter defines how many decimal places each float should have, defaulting to 2. The tuple is presented in this stri ng format: "(list1, list2)".