API / Js / String-2

# String2

Provide bindings to JS string. Optimized for pipe-first.

## t

```RES```type t = string
``````

## make

``````let make: 'a => t
``````

`make(value)` converts the given value to a `string`.

```RES```Js.String2.make(3.5) == "3.5"
Js.String2.make([1, 2, 3]) == "1,2,3"
``````

## fromCharCode

``````let fromCharCode: int => t
``````

`fromCharCode(n)` creates a `string` containing the character corresponding to that number; `n` ranges from 0 to 65535. If out of range, the lower 16 bits of the value are used. Thus, `fromCharCode(0x1F63A)` gives the same result as `fromCharCode(0xF63A)`. See `String.fromCharCode` on MDN.

```RES```Js.String2.fromCharCode(65) == "A"
Js.String2.fromCharCode(0x3c8) == `ψ`
Js.String2.fromCharCode(0xd55c) == `한`
Js.String2.fromCharCode(-64568) == `ψ`
``````

## fromCharCodeMany

``````let fromCharCodeMany: array<int> => t
``````

`fromCharCodeMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given numbers, using the same rules as `fromCharCode`. See `String.fromCharCode` on MDN.

## fromCodePoint

``````let fromCodePoint: int => t
``````

`fromCodePoint(n)` creates a `string` containing the character corresponding to that numeric code point. If the number is not a valid code point, it raises `RangeError`. Thus, `fromCodePoint(0x1F63A)` will produce a correct value, unlike `fromCharCode(0x1F63A)`, and `fromCodePoint(-5)` will raise a `RangeError`. See `String.fromCodePoint` on MDN.

```RES```Js.String2.fromCodePoint(65) == "A"
Js.String2.fromCodePoint(0x3c8) == `ψ`
Js.String2.fromCodePoint(0xd55c) == `한`
Js.String2.fromCodePoint(0x1f63a) == `😺`
``````

## fromCodePointMany

``````let fromCodePointMany: array<int> => t
``````

`fromCodePointMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given code point numbers, using the same rules as `fromCodePoint`. See `String.fromCodePoint` on MDN.

```RES```Js.String2.fromCodePointMany([0xd55c, 0xae00, 0x1f63a]) == `한글😺`
``````

## length

``````let length: t => int
``````

`length(s)` returns the length of the given `string`. See `String.length` on MDN.

```RES```Js.String2.length("abcd") == 4
``````

## get

``````let get: (t, int) => t
``````

`get(s, n)` returns as a `string` the character at the given index number. If `n` is out of range, this function returns `undefined`, so at some point this function may be modified to return `option<string>`.

```RES```Js.String2.get("Reason", 0) == "R"
Js.String2.get("Reason", 4) == "o"
Js.String2.get(`Rẽasöń`, 5) == `ń`
``````

## charAt

``````let charAt: (t, int) => t
``````

`charAt(s, n)` gets the character at index `n` within string `s`. If `n` is negative or greater than the length of `s`, it returns the empty string. If the string contains characters outside the range \u0000-\uffff, it will return the first 16-bit value at that position in the string. See `String.charAt` on MDN.

```RES```Js.String2.charAt("Reason", 0) == "R"
Js.String2.charAt("Reason", 12) == ""
Js.String2.charAt(`Rẽasöń`, 5) == `ń`
``````

## charCodeAt

``````let charCodeAt: (t, int) => float
``````

`charCodeAt(s, n)` returns the character code at position `n` in string `s`; the result is in the range 0-65535, unlke `codePointAt`, so it will not work correctly for characters with code points greater than or equal to 0x10000. The return type is `float` because this function returns NaN if `n` is less than zero or greater than the length of the string. See `String.charCodeAt` on MDN.

```RES```Js.String2.charCodeAt(`😺`, 0) == 0xd83d->Belt.Int.toFloat
Js.String2.codePointAt(`😺`, 0) == Some(0x1f63a)
``````

## codePointAt

``````let codePointAt: (t, int) => option<int>
``````

`codePointAt(s, n)` returns the code point at position `n` within string `s` as a `Some(value)`. The return value handles code points greater than or equal to 0x10000. If there is no code point at the given position, the function returns `None`. See `String.codePointAt` on MDN.

```RES```Js.String2.codePointAt(`¿😺?`, 1) == Some(0x1f63a)
Js.String2.codePointAt("abc", 5) == None
``````

## concat

``````let concat: (t, t) => t
``````

`concat(original, append)` returns a new `string` with `append` added after `original`. See `String.concat` on MDN.

```RES```Js.String2.concat("cow", "bell") == "cowbell"
``````

## concatMany

``````let concatMany: (t, array<t>) => t
``````

`concat(original, arr)` returns a new `string` consisting of each item of an array of strings added to the `original` string. See `String.concat` on MDN.

```RES```Js.String2.concatMany("1st", ["2nd", "3rd", "4th"]) == "1st2nd3rd4th"
``````

## endsWith

``````let endsWith: (t, t) => bool
``````

ES2015: `endsWith(str, substr)` returns `true` if the `str` ends with `substr`, `false` otherwise. See `String.endsWith` on MDN.

```RES```Js.String2.endsWith("BuckleScript", "Script") == true
Js.String2.endsWith("BuckleShoes", "Script") == false
``````

## endsWithFrom

``````let endsWithFrom: (t, t, int) => bool
``````

`endsWithFrom(str, ending, len)` returns `true` if the first len characters of `str` end with `ending`, `false` otherwise. If `len` is greater than or equal to the length of `str`, then it works like `endsWith`. (Honestly, this should have been named endsWithAt, but oh well.) See `String.endsWith` on MDN.

```RES```Js.String2.endsWithFrom("abcd", "cd", 4) == true
Js.String2.endsWithFrom("abcde", "cd", 3) == false
Js.String2.endsWithFrom("abcde", "cde", 99) == true
Js.String2.endsWithFrom("example.dat", "ple", 7) == true
``````

## includes

``````let includes: (t, t) => bool
``````

ES2015: `includes(str, searchValue)` returns `true` if `searchValue` is found anywhere within `str`, false otherwise. See `String.includes` on MDN.

```RES```Js.String2.includes("programmer", "gram") == true
Js.String2.includes("programmer", "er") == true
Js.String2.includes("programmer", "pro") == true
Js.String2.includes("programmer.dat", "xyz") == false
``````

## includesFrom

``````let includesFrom: (t, t, int) => bool
``````

ES2015: `includes(str, searchValue start)` returns `true` if `searchValue` is found anywhere within `str` starting at character number `start` (where 0 is the first character), `false` otherwise. See `String.includes` on MDN.

```RES```Js.String2.includesFrom("programmer", "gram", 1) == true
Js.String2.includesFrom("programmer", "gram", 4) == false
Js.String2.includesFrom(`대한민국`, `한`, 1) == true
``````

## indexOf

``````let indexOf: (t, t) => int
``````

ES2015: `indexOf(str, searchValue)` returns the position at which `searchValue` was first found within `str`, or -1 if `searchValue` is not in `str`. See `String.indexOf` on MDN.

```RES```Js.String2.indexOf("bookseller", "ok") == 2
Js.String2.indexOf("bookseller", "sell") == 4
Js.String2.indexOf("beekeeper", "ee") == 1
Js.String2.indexOf("bookseller", "xyz") == -1
``````

## indexOfFrom

``````let indexOfFrom: (t, t, int) => int
``````

`indexOfFrom(str, searchValue, start)` returns the position at which `searchValue` was found within `str` starting at character position `start`, or -1 if `searchValue` is not found in that portion of `str`. The return value is relative to the beginning of the string, no matter where the search started from. See `String.indexOf` on MDN.

```RES```Js.String2.indexOfFrom("bookseller", "ok", 1) == 2
Js.String2.indexOfFrom("bookseller", "sell", 2) == 4
Js.String2.indexOfFrom("bookseller", "sell", 5) == -1
``````

## lastIndexOf

``````let lastIndexOf: (t, t) => int
``````

`lastIndexOf(str, searchValue)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the end of the string. Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See `String.lastIndexOf` on MDN.

```RES```Js.String2.lastIndexOf("bookseller", "ok") == 2
Js.String2.lastIndexOf("beekeeper", "ee") == 4
Js.String2.lastIndexOf("abcdefg", "xyz") == -1
``````

## lastIndexOfFrom

``````let lastIndexOfFrom: (t, t, int) => int
``````

`lastIndexOfFrom(str, searchValue, start)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the given start position. Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See `String.lastIndexOf` on MDN.

```RES```Js.String2.lastIndexOfFrom("bookseller", "ok", 6) == 2
Js.String2.lastIndexOfFrom("beekeeper", "ee", 8) == 4
Js.String2.lastIndexOfFrom("beekeeper", "ee", 3) == 1
Js.String2.lastIndexOfFrom("abcdefg", "xyz", 4) == -1
``````

## localeCompare

``````let localeCompare: (t, t) => float
``````

`localeCompare(reference, comparison)` returns

• a negative value if reference comes before comparison in sort order

• zero if reference and comparison have the same sort order

• a positive value if reference comes after comparison in sort order

See `String.localeCompare` on MDN.

```RES```Js.String2.localeCompare("zebra", "ant") > 0.0
Js.String2.localeCompare("ant", "zebra") < 0.0
Js.String2.localeCompare("cat", "cat") == 0.0
Js.String2.localeCompare("CAT", "cat") > 0.0
``````

## match

``````let match_: (t, Js_re.t) => option<array<option<t>>>
``````

`match(str, regexp)` matches a `string` against the given `regexp`. If there is no match, it returns `None`. For regular expressions without the g modifier, if there is a match, the return value is `Some(array)` where the array contains:

• The entire matched string

• Any capture groups if the regexp had parentheses

For regular expressions with the g modifier, a matched expression returns `Some(array)` with all the matched substrings and no capture groups. Javscript String.prototype.match can return `undefined` for optional capture groups that are not found, thus the element of the returned array is typed `option<t>`. See `String.match` on MDN.

```RES```Js.String2.match_("The better bats", %re("/b[aeiou]t/")) == Some([Some("bet")])
Js.String2.match_("The better bats", %re("/b[aeiou]t/g")) == Some([Some("bet"), Some("bat")])
Js.String2.match_("Today is 2018-04-05.", %re("/(\d+)-(\d+)-(\d+)/")) ==
Some([Some("2018-04-05"), Some("2018"), Some("04"), Some("05")])
Js.String2.match_("The large container.", %re("/b[aeiou]g/")) == None
``````

## normalize

``````let normalize: t => t
``````

`normalize(str)` returns the normalized Unicode string using Normalization Form Canonical (NFC) Composition. Consider the character ã, which can be represented as the single codepoint \u00e3 or the combination of a lower case letter A \u0061 and a combining tilde \u0303. Normalization ensures that both can be stored in an equivalent binary representation. See `String.normalize` on MDN. See also Unicode technical report #15 for details.

## normalizeByForm

``````let normalizeByForm: (t, t) => t
``````

ES2015: `normalize(str, form)` returns the normalized Unicode string using the specified form of normalization, which may be one of:

• "NFC" — Normalization Form Canonical Composition.

• "NFD" — Normalization Form Canonical Decomposition.

• "NFKC" — Normalization Form Compatibility Composition.

• "NFKD" — Normalization Form Compatibility Decomposition.

See `String.normalize` on MDN. See also Unicode technical report #15 for details..

## repeat

``````let repeat: (t, int) => t
``````

`repeat(str, n)` returns a `string` that consists of `n` repetitions of `str`. Raises `RangeError` if `n` is negative. See `String.repeat` on MDN.

```RES```Js.String2.repeat("ha", 3) == "hahaha"
Js.String2.repeat("empty", 0) == ""
``````

## replace

``````let replace: (t, t, t) => t
``````

ES2015: `replace(str, substr, newSubstr)` returns a new `string` which is identical to `str` except with the first matching instance of `substr` replaced by `newSubstr`. `substr` is treated as a verbatim string to match, not a regular expression. See `String.replace` on MDN.

```RES```Js.String2.replace("old string", "old", "new") == "new string"
Js.String2.replace("the cat and the dog", "the", "this") == "this cat and the dog"
``````

## replaceByRe

``````let replaceByRe: (t, Js_re.t, t) => t
``````

`replaceByRe(str, regex, replacement)` returns a new `string` where occurrences matching regex have been replaced by `replacement`. See `String.replace` on MDN.

```RES```Js.String2.replaceByRe("vowels be gone", %re("/[aeiou]/g"), "x") == "vxwxls bx gxnx"
Js.String2.replaceByRe("Juan Fulano", %re("/(\w+) (\w+)/"), "\$2, \$1") == "Fulano, Juan"
``````

## unsafeReplaceBy0

``````let unsafeReplaceBy0: (t, Js_re.t, (t, int, t) => t) => t
``````

Returns a new `string` with some or all matches of a pattern with no capturing parentheses replaced by the value returned from the given function. The function receives as its parameters the matched string, the offset at which the match begins, and the whole string being matched. See `String.replace` on MDN.

```RES```let str = "beautiful vowels"
let re = %re("/[aeiou]/g")
let matchFn = (matchPart, _offset, _wholeString) => Js.String2.toUpperCase(matchPart)

Js.String2.unsafeReplaceBy0(str, re, matchFn) == "bEAUtIfUl vOwEls"
``````

## unsafeReplaceBy1

``````let unsafeReplaceBy1: (t, Js_re.t, (t, t, int, t) => t) => t
``````

Returns a new `string` with some or all matches of a pattern with one set of capturing parentheses replaced by the value returned from the given function. The function receives as its parameters the matched string, the captured string, the offset at which the match begins, and the whole string being matched. See `String.replace` on MDN.

```RES```let str = "Jony is 40"
let re = %re("/(Jony is )\d+/g")
let matchFn = (_match, part1, _offset, _wholeString) => {
part1 ++ "41"
}

Js.String2.unsafeReplaceBy1(str, re, matchFn) == "Jony is 41"
``````

## unsafeReplaceBy2

``````let unsafeReplaceBy2: (t, Js_re.t, (t, t, t, int, t) => t) => t
``````

Returns a new `string` with some or all matches of a pattern with two sets of capturing parentheses replaced by the value returned from the given function. The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See `String.replace` on MDN.

```RES```let str = "7 times 6"
let re = %re("/(\d+) times (\d+)/")
let matchFn = (_match, p1, p2, _offset, _wholeString) => {
switch (Belt.Int.fromString(p1), Belt.Int.fromString(p2)) {
| (Some(x), Some(y)) => Belt.Int.toString(x * y)
| _ => "???"
}
}

Js.String2.unsafeReplaceBy2(str, re, matchFn) == "42"
``````

## unsafeReplaceBy3

``````let unsafeReplaceBy3: (t, Js_re.t, (t, t, t, t, int, t) => t) => t
``````

Returns a new `string` with some or all matches of a pattern with three sets of capturing parentheses replaced by the value returned from the given function. The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See `String.replace` on MDN.

## search

``````let search: (t, Js_re.t) => int
``````

`search(str, regexp)` returns the starting position of the first match of `regexp` in the given `str`, or -1 if there is no match. See `String.search` on MDN.

```RES```Js.String2.search("testing 1 2 3", %re("/\d+/")) == 8
Js.String2.search("no numbers", %re("/\d+/")) == -1
``````

## slice

``````let slice: (t, ~from: int, ~to_: int) => t
``````

`slice(str, from:n1, to_:n2)` returns the substring of `str` starting at character `n1` up to but not including `n2`.

• If either `n1` or `n2` is negative, then it is evaluated as `length(str - n1)` or `length(str - n2)`.

• If `n2` is greater than the length of `str`, then it is treated as `length(str)`.

• If `n1` is greater than `n2`, slice returns the empty string.

See `String.slice` on MDN.

```RES```Js.String2.slice("abcdefg", ~from=2, ~to_=5) == "cde"
Js.String2.slice("abcdefg", ~from=2, ~to_=9) == "cdefg"
Js.String2.slice("abcdefg", ~from=-4, ~to_=-2) == "de"
Js.String2.slice("abcdefg", ~from=5, ~to_=1) == ""
``````

## sliceToEnd

``````let sliceToEnd: (t, ~from: int) => t
``````

`sliceToEnd(str, from:n)` returns the substring of `str` starting at character `n` to the end of the string.

• If `n` is negative, then it is evaluated as `length(str - n)`.

• If `n` is greater than the length of `str`, then sliceToEnd returns the empty string.

See `String.slice` on MDN.

```RES```Js.String2.sliceToEnd("abcdefg", ~from=4) == "efg"
Js.String2.sliceToEnd("abcdefg", ~from=-2) == "fg"
Js.String2.sliceToEnd("abcdefg", ~from=7) == ""
``````

## split

``````let split: (t, t) => array<t>
``````

`split(str, delimiter)` splits the given `str` at every occurrence of `delimiter` and returns an array of the resulting substrings. See `String.split` on MDN.

```RES```Js.String2.split("2018-01-02", "-") == ["2018", "01", "02"]
Js.String2.split("a,b,,c", ",") == ["a", "b", "", "c"]
Js.String2.split("has-no-delimiter", ";") == ["has-no-delimiter"]
``````

## splitAtMost

``````let splitAtMost: (t, t, ~limit: int) => array<t>
``````

`splitAtMost(str, delimiter, ~limit:n)` splits the given `str` at every occurrence of `delimiter` and returns an array of the first `n` resulting substrings. If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See `String.split` on MDN.

```RES```Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=3) == ["ant", "bee", "cat"]
Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=0) == []
Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=9) == [
"ant",
"bee",
"cat",
"dog",
"elk",
]
``````

## splitByRe

``````let splitByRe: (t, Js_re.t) => array<option<t>>
``````

`splitByRe(str, regex)` splits the given `str` at every occurrence of `regex` and returns an array of the resulting substrings. See `String.split` on MDN.

```RES```Js.String2.splitByRe("art; bed , cog ;dad", %re("/\s*[,;]\s*/")) == [
Some("art"),
Some("bed"),
Some("cog"),
]
``````

## splitByReAtMost

``````let splitByReAtMost: (t, Js_re.t, ~limit: int) => array<option<t>>
``````

`splitByReAtMost(str, regex, ~limit:n)` splits the given `str` at every occurrence of `regex` and returns an array of the first `n` resulting substrings. If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See `String.split` on MDN.

```RES```Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=3) == [
Some("one"),
Some("two"),
Some("three"),
]

Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=0) == []

Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=8) == [
Some("one"),
Some("two"),
Some("three"),
Some("four"),
]
``````

## startsWith

``````let startsWith: (t, t) => bool
``````

ES2015: `startsWith(str, substr)` returns `true` if the `str` starts with `substr`, `false` otherwise. See `String.startsWith` on MDN.

```RES```Js.String2.startsWith("BuckleScript", "Buckle") == true
Js.String2.startsWith("BuckleScript", "") == true
Js.String2.startsWith("JavaScript", "Buckle") == false
``````

## startsWithFrom

``````let startsWithFrom: (t, t, int) => bool
``````

ES2015: `startsWithFrom(str, substr, n)` returns `true` if the `str` starts with `substr` starting at position `n`, false otherwise. If `n` is negative, the search starts at the beginning of `str`. See `String.startsWith` on MDN.

```RES```Js.String2.startsWithFrom("BuckleScript", "kle", 3) == true
Js.String2.startsWithFrom("BuckleScript", "", 3) == true
Js.String2.startsWithFrom("JavaScript", "Buckle", 2) == false
``````

## substr

``````let substr: (t, ~from: int) => t
``````

`substr(str, ~from:n)` returns the substring of `str` from position `n` to the end of the string.

• If `n` is less than zero, the starting position is the length of `str - n`.

• If `n` is greater than or equal to the length of `str`, returns the empty string.

JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See `String.substr` on MDN.

```RES```Js.String2.substr("abcdefghij", ~from=3) == "defghij"
Js.String2.substr("abcdefghij", ~from=-3) == "hij"
Js.String2.substr("abcdefghij", ~from=12) == ""
``````

## substrAtMost

``````let substrAtMost: (t, ~from: int, ~length: int) => t
``````

`substrAtMost(str, ~from: pos, ~length: n)` returns the substring of `str` of length `n` starting at position `pos`.

• If `pos` is less than zero, the starting position is the length of `str - pos`.

• If `pos` is greater than or equal to the length of `str`, returns the empty string.

• If `n` is less than or equal to zero, returns the empty string.

JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See `String.substr` on MDN.

```RES```Js.String2.substrAtMost("abcdefghij", ~from=3, ~length=4) == "defg"
Js.String2.substrAtMost("abcdefghij", ~from=-3, ~length=4) == "hij"
Js.String2.substrAtMost("abcdefghij", ~from=12, ~length=2) == ""
``````

## substring

``````let substring: (t, ~from: int, ~to_: int) => t
``````

`substring(str, ~from: start, ~to_: finish)` returns characters `start` up to but not including finish from `str`.

• If `start` is less than zero, it is treated as zero.

• If `finish` is zero or negative, the empty string is returned.

• If `start` is greater than `finish`, the `start` and `finish` points are swapped.

See `String.substring` on MDN.

```RES```Js.String2.substring("playground", ~from=3, ~to_=6) == "ygr"
Js.String2.substring("playground", ~from=6, ~to_=3) == "ygr"
Js.String2.substring("playground", ~from=4, ~to_=12) == "ground"
``````

## substringToEnd

``````let substringToEnd: (t, ~from: int) => t
``````

`substringToEnd(str, ~from: start)` returns the substring of `str` from position `start` to the end.

• If `start` is less than or equal to zero, the entire string is returned.

• If `start` is greater than or equal to the length of `str`, the empty string is returned.

See `String.substring` on MDN.

```RES```Js.String2.substringToEnd("playground", ~from=4) == "ground"
Js.String2.substringToEnd("playground", ~from=-3) == "playground"
Js.String2.substringToEnd("playground", ~from=12) == ""
``````

## toLowerCase

``````let toLowerCase: t => t
``````

`toLowerCase(str)` converts `str` to lower case using the locale-insensitive case mappings in the Unicode Character Database. Notice that the conversion can give different results depending upon context, for example with the Greek letter sigma, which has two different lower case forms; one when it is the last character in a string and another when it is not. See `String.toLowerCase` on MDN.

```RES```Js.String2.toLowerCase("ABC") == "abc"
Js.String2.toLowerCase(`ΣΠ`) == `σπ`
Js.String2.toLowerCase(`ΠΣ`) == `πς`
``````

## toLocaleLowerCase

``````let toLocaleLowerCase: t => t
``````

`toLocaleLowerCase(str)` converts `str` to lower case using the current locale. See `String.toLocaleLowerCase` on MDN.

## toUpperCase

``````let toUpperCase: t => t
``````

`toUpperCase(str)` converts `str` to upper case using the locale-insensitive case mappings in the Unicode Character Database. Notice that the conversion can expand the number of letters in the result; for example the German ß capitalizes to two Ses in a row. See `String.toUpperCase` on MDN.

```RES```Js.String2.toUpperCase("abc") == "ABC"
Js.String2.toUpperCase(`Straße`) == `STRASSE`
Js.String2.toUpperCase(`πς`) == `ΠΣ`
``````

## toLocaleUpperCase

``````let toLocaleUpperCase: t => t
``````

`toLocaleUpperCase(str)` converts `str` to upper case using the current locale. See `String.to:LocaleUpperCase` on MDN.

## trim

``````let trim: t => t
``````

`trim(str)` returns a string that is `str` with whitespace stripped from both ends. Internal whitespace is not removed. See `String.trim` on MDN.

```RES```Js.String2.trim("   abc def   ") == "abc def"
Js.String2.trim("\n\r\t abc def \n\n\t\r ") == "abc def"
``````

## anchor

``````let anchor: (t, t) => t
``````

`anchor(anchorText, anchorName)` creates a string with an HTML `<a>` element with name attribute of `anchorName` and `anchorText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See `String.anchor` on MDN.

```RES```Js.String2.anchor("Page One", "page1") == "<a name=\"page1\">Page One</a>"
``````

``````let link: (t, t) => t
``````

ES2015: `link(linkText, urlText)` creates a string with an HTML `<a>` element with href attribute of `urlText` and `linkText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See `String.link` on MDN.

```RES```Js.String2.link("Go to page two", "page2.html") == "<a href=\"page2.html\">Go to page two</a>"
``````

## castToArrayLike

``````let castToArrayLike: t => Js_array2.array_like<t>
``````

Casts its argument to an `array_like` entity that can be processed by functions such as `Js.Array2.fromMap()`

```RES```let s = "abcde"
let arr = Js.Array2.fromMap(Js.String2.castToArrayLike(s), x => x)
arr == ["a", "b", "c", "d", "e"]
``````
{"ft_lang_label":"__label__en","ft_lang_prob":0.5782153,"math_prob":0.9223547,"size":22906,"snap":"2023-40-2023-50","text_gpt3_token_len":6665,"char_repetition_ratio":0.19024539,"word_repetition_ratio":0.24293785,"special_character_ratio":0.28686807,"punctuation_ratio":0.21526419,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9565491,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-09-23T03:48:26Z\",\"WARC-Record-ID\":\"<urn:uuid:144f664e-7b96-442d-a6a1-f7d48689ae68>\",\"Content-Length\":\"269589\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:fa7502de-5a56-4e7c-8300-a3092c1bd05e>\",\"WARC-Concurrent-To\":\"<urn:uuid:1285ab25-b194-4004-a3e9-578bf36c0d30>\",\"WARC-IP-Address\":\"76.223.126.88\",\"WARC-Target-URI\":\"https://rescript-lang.org/docs/manual/latest/api/js/string-2\",\"WARC-Payload-Digest\":\"sha1:TBY55LDREEOE3HJZQBD5KMJCL24XLFHP\",\"WARC-Block-Digest\":\"sha1:HTZ7W2FQWDZGO63ON72RYMEF7LFUFKOW\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-40/CC-MAIN-2023-40_segments_1695233506479.32_warc_CC-MAIN-20230923030601-20230923060601-00348.warc.gz\"}"}