-spec align_rows(Rows :: [tuple() | binary() | list()],
                 Options ::
                     [{pad,
                       Dir ::
                           [trailing | leading | both |
                            {Pos :: integer() | last, trailing | leading | both | none}]} |
                      {exclude, Cols :: [integer()]} |
                      {return, Ret :: tuple | list} |
                      {type, binary | charlist} |
                      {prefix, string()} |
                      {ignore_empty, boolean()}]) ->
                    [AlignedRow :: tuple() | list()].

Align rows of terms by stringifying them to uniform column width. If some row doesn't need to be aligned, pass its value as a binary. Options can be:

Rows is a list. All rows must have the same arity except if a row is a binary. Options contain:

• {pad, Direction} — Column padding direction, where Direction is one of leading, trailing, {Position::integer(), leading|trailing|none}, {last, leading|trailing|none}
• {type, binary|charlist} — Return columns in the result rows as binaries or charlists (default)
• {return, tuple|list} — Return result rows as lists or tuples
• {prefix, string()} — Prefix first item in each row with this string
• {ignore_empty, boolean()} — Don't pad trailing empty columns if this option is true
• {exclude, [integer()]} — Exclude given column numbers

-spec batch_split(integer(), list()) -> [list()].

Split a list into batches of N items

-spec format(binary() | string(), list()) -> binary() | string().

Convert format and arguments to binary/list shortening . This function can be used by Elixir, which is missing the equivalent of io_lib.format/2

-spec format_binary(binary() | string(), list()) -> binary().

Convert format and arguments to binary/list shortening . This function can be used by Elixir, which is missing the equivalent of io_lib.format/2

-spec format_number(number(), precision(), decimals()) -> formatted_number().

The same as uef_format:format_number/4 with #{} as the forth argument. See: format_number/4.

-spec format_number(number(), precision(), decimals(), format_number_opts()) -> formatted_number().

Formats Number by adding thousands separator between each set of 3 digits to the left of the decimal point, substituting Decimals for the decimal point, and rounding to the specified Precision. Returns a binary value.

-spec format_price(Number :: number()) -> FormattedPrice :: formatted_number().

Formats Number in price-like style. Returns a binary containing FormattedPrice formatted with a precision of 2 and decimal digits of 2. The same as format_price/2 with a precision of 2 as the second argument. See uef_format:format_price/2 docs.

-spec format_price(Number :: number(), Precision :: precision()) -> formatted_number().

Formats Number in price-like style. Returns a binary containing FormattedPrice formatted with a specified precision as the second argument and decimal digits of 2. The same as uef_format:format_price/3 with #{} as the third argument. See: format_price/3.

-spec format_price(Number :: number(),
                   Precision :: precision(),
                   CcySymbol_OR_Options :: format_number_opts() | ccy_sym()) ->
                      FormattedPrice :: formatted_number().

Formats Number in price-like style. Returns a binary containing FormattedPrice formatted with a specified precision as the second argument, decimal digits of 2, and with ccy symbol (or options) as the third argument. If CcySymbol_OR_Options is a map the functions works as format_number/4 with decimal digits of 2 as the third argument and with options as the forth one. If CcySymbol_OR_Options is a binary or a string, the corresponding ccy symbol is added to the left.

-spec parse_csv(string()) -> [[string()]].

Parse a given CSV file.

-spec parse_csv(string(), [fix_lengths | {open, Opts :: list()}]) -> [[string()]].

Parse a given CSV file.

-spec pretty_print_table([map()]) -> ok.

Pretty print table of lists/tuples/maps to list. The following options control formatting behavior:

• header — When true (default), output header row
• number_pad — Leading padding character used for numbers
• th_dir — Table header row padding direction (both|leading|trailing)
• td_dir — Table row padding direction (both|leading|trailing)
• td_start — Don't print columns less than this (e.g. use 2 for records)
• td_exclulde — List of column ID's (starting with 1) or names to exclude
• td_pad — A map containing column padding directions #{Col::integer() => both|leading|trailing.

• td_sep — Column separator (default " | ")

• tr_sep — Row separator (default "-")
• tr_sep_td — Column delimiter used in separating rows ("+")
• prefix — Prepend each row with this string
• td_formats — A tuple containing column formats. Each value is either a format string passed to io_lib:format/2 or a function taking either one argument fun(Value) -> {number|string, FormattedValue::string()} or three arguments fun(Key,Value,Row::tuple()|map()) -> {number|string, FormattedValue::string()}. This three argument function can perform calculation of the field value based on values of other fields in the Row.
• unicode — Use unicode outline characters
• outline — Draw top, left and line box outline (by default only the bottom one is drawn). Values:
  • none - on outline box
  • full - outline box on all 4 sides
  • [top, left, bottom, right] - outline box on given sides

Example:

1> stringx:pretty_print_table(
{a,b,c,d}, [{a, 10, ccc}, {bxxx, 200.00123, 'Done'}, {abc, 100.0, xx}],
#opts{td_dir=both, td_exclude=[d], td_formats=
{undefined, fun(V) when is_integer(V) -> {number, integer_to_list(V)};
(V) when is_float(V)   -> {number, float_to_list(V, [{decimals, 5}])}
end, "~w"}}).
a   |     b     |   c
-----+-----------+-------
a   |        10 |  ccc
bxxx | 200.00123 | 'Done'
-----+-----------+-------

-spec pretty_table([map()]) -> list().

Pretty print list of maps to list. See: pretty_table/3..

-spec pretty_table([binary() | string() | atom()], [Row :: tuple() | list() | map()]) -> list().

Pretty print table of lists/tuples/maps to list. See: pretty_table/3..

-spec round_number(Number :: number(), Precision :: integer()) -> float().

Rounds the number to the specified precision.

-spec round_price(Number :: number()) -> float().

Rounds the number to the precision of 2.

-spec titlecase(string()) -> string().

Convert words in a string to capitalize first letter of each word.

-spec wordwrap(string() | binary(), integer()) -> string() | binary().

Wrap words list in a string to multiple lines that fit the margin There are two uses of this function: First:

1> stringx:wordwrap("abc efg exdf"], 8, "\n"). "abc efg\nexdf"

Second:

1> stringx:wordwrap(["abc", "efg", "exdf"], 8, ","). ["abc,efg,","exdf"]

The second use is deprecated. Use wrap_words/3 instead.

-spec wrap_words([Word], integer(), Word) -> [Word] when Word :: string() | binary().

Wrap words list in a string to multiple lines that fit the margin Example: