# Module `Jstr`

JavaScript strings

`val v : string -> t`

`v s`

is the UTF-8 encoded OCaml string`s`

as a JavaScript string.

`val length : t -> int`

`length s`

is the length of`s`

.

`val get : t -> int -> Stdlib.Uchar.t`

`get s i`

is the Unicode character at position`i`

in`s`

. If this happens to be a lone low or any high surrogate surrogate,`Uchar`

.rep is returned. Raises`Invalid_argument`

if`i`

is out of bounds.

## Constants

`val empty : t`

`empty`

is an empty string.

`val sp : t`

`sp`

is`Jstr.v " "`

.

`val nl : t`

`nl`

is`Jstr.v "\n"`

.

## Assembling

`val concat : ?sep:t -> t list -> t`

`concat ?sep ss`

is the concatenates the list of strings`ss`

inserting`sep`

between each of them (defaults to`empty`

).

`val pad_start : ?pad:t -> int -> t -> t`

`pad_start ~pad n s`

is`s`

with`pad`

strings prepended to`s`

until the length of the result is`n`

or`s`

if`length s >= n`

. The first prepended`pad`

may be truncated to satisfy the constraint.**Warning.**Since`length`

is neither the number of Unicode characters of`s`

nor its number of grapheme clusters, if you are using this for visual layout, it will fail in many cases. At least consider normalizing`s`

to``NFC`

before.

`val pad_end : ?pad:t -> int -> t -> t`

`pad_end ~pad n s`

is`s`

with`pad`

strings appended to`s`

until the`length`

of the result is`n`

or`s`

if`length s >= n`

. The last appended`pad`

may be truncated to satisfy the constraint.**Warning.**Since`length`

is neither the number of Unicode characters of`s`

nor its number of grapheme clusters, if you are using this for visual layout, it will fail in many cases. At least consider normalizing`s`

to``NFC`

before.

## Finding

## Breaking

`val slice : ?start:int -> ?stop:int -> t -> t`

`slice ~start ~stop s`

is the string s.`start`

, s.`start+1`

, ... s.`stop - 1`

.`start`

defaults to`0`

and`stop`

to`length s`

.If

`start`

or`stop`

are negative they are subtracted from`length s`

. This means that`-1`

denotes the last character of the string.

`val sub : ?start:int -> ?len:int -> t -> t`

`sub ~start ~len s`

is the string s.`start`

, ... s.`start + len - 1`

.`start`

default to`0`

and`len`

to`length s - start`

.If

`start`

is negative it is subtracted from`length s`

. This means that`-1`

denotes the last character of the string. If`len`

is negative it is treated as`0`

.

## Traversing and transforming

`val fold_uchars : (Stdlib.Uchar.t -> 'a -> 'a) -> t -> 'a -> 'a`

`fold_uchars f acc s`

folds`f`

over the Unicode characters of`s`

starting with`acc`

. Decoding errors (that is unpaired UTF-16 surrogates) are reported as`Uchar`

.rep.

`val fold_jstr_uchars : (t -> 'a -> 'a) -> t -> 'a -> 'a`

`fold_jstr_uchars`

is like`fold_uchars`

but the characters are given as strings.

## Normalization

For more information on normalization consult a short introduction, the UAX #15 Unicode Normalization Forms and normalization charts.

`type normalization`

=`[`

`|`

``NFD`

`|`

``NFC`

`|`

``NFKD`

`|`

``NFKC`

`]`

The type for normalization forms.

``NFD`

normalization form D, canonical decomposition.``NFC`

normalization form C, canonical decomposition followed by canonical composition.``NFKD`

normalization form KD, compatibility decomposition.``NFKC`

normalization form KC, compatibility decomposition, followed by canonical composition.

`val normalized : normalization -> t -> t`

`normalized nf t`

is`t`

normalized to`nf`

.

## Case mapping

For more information about case see the Unicode case mapping FAQ and the case mapping charts. Note that these algorithms are insensitive to language and context and may produce sub-par results for some users.

## Predicates and comparisons

`val is_empty : t -> bool`

`is_empty s`

is`true`

iff`s`

is an empty string.

`val starts_with : sub:t -> t -> bool`

`starts_with ~sub s`

is`true`

iff`s`

starts with`sub`

(as per`equal`

).

## Conversions

`val of_uchar : Stdlib.Uchar.t -> t`

`of_uchar u`

is a string made of`u`

.

`val of_char : char -> t`

`of_char c`

is a string made of`c`

.

`val to_string : t -> string`

`to_string s`

is`s`

as an UTF-8 encoded OCaml string.

`val of_string : string -> t`

`of_string s`

is the UTF-8 encoded OCaml string`s`

as a JavaScript string.

`val to_int : ?base:int -> t -> int option`

`to_int s`

is the integer resulting from parsing`s`

as a number in base`base`

(guessed by default). The function uses`Number.parseInt`

and maps`Float`

.nan results to`None`

.

`val of_int : ?base:int -> int -> t`

`of_int ~base i`

formats`i`

as a number in base`base`

(defaults to`10`

). Conversion is performed via`Number.toString`

.

`val to_float : t -> float`

`to_float s`

is the floating point number resulting from parsing`s`

. This always succeeds and returns`Float`

.nan on unparseable inputs. The function uses`Number.parseFloat`

.

`val of_float : ?frac:int -> float -> t`

`of_float ~frac n`

formats`n`

with`frac`

fixed fractional digits (or as needed if unspecified). This function uses`Number.toFixed`

if`f`

is specified and`Number.toString`

otherwise.