Substring.t is the type of substrings of a basestring, an efficient representation of a piece of a string.

A substring (s,i,n) is valid if 0 <= i <= i+n <= size s, or equivalently, 0 <= i and 0 <= n and i+n <= size s.

A valid substring (s, i, n) represents the string si...i+n-1.

Invariant in the implementation: Any value of type Substring.t is valid.

string sus is the string si..i+n-1 represented by sus = (s, i, n).

Substring equality

• since 2.1

substring s o l returns a substring with base-string s, offset o and length l. Arguments are checked for validity

substring s i n creates the substring (s, i, n), consisting of the substring of s with length n starting at i.

• raises Inavlid_argument

  if i<0 or n<0 or i+n > size s. Equivalent to extract s i (Some n).

unsafe_substring behaves like substring, but does not perform any sanity check on the position and length.

extract s i None creates the substring (s, i, size s-i) consisting of the tail of s starting at i.

• raises Invalid_argument

  if i<0 or i > size s.

extract s i (Some n) creates the substring (s, i, n), consisting of the substring of s with length n starting at i.

• raises Invalid_argument

  if i<0 or n<0 or i+n > size s.

all s is the substring (s, 0, size s).

base sus is the concrete triple (s, i, n), where psus = (s, i, n).

is_empty (s, i, n) true if the substring is empty (that is, n = 0).

getc sus returns Some(c, rst) where c is the first character and rst the remainder of sus, if sus is non-empty; otherwise returns None.

first sus returns Some c where c is the first character in sus, if sus is non-empty; otherwise returns None.

triml k sus returns sus less its leftmost k characters; or the empty string at the end of sus if it has less than k characters.

• raises Invalid_argument

  if k < 0, even in the partial application triml k.

trimr k sus returns sus less its rightmost k characters; or the empty string at the beginning of sus if it has less than k characters.

• raises Invalid_argument

  if k < 0, even in the partial application trimr k.

get sus k returns the k'th character of the substring; that is, s(i+k) where sus = (s, i, n).

• raises Invalid_argument

  if k<0 or k>=n.

size (s, i, n) returns the size of the substring, that is, n.

Equivalent to size.

slice sus i' None returns the substring (s, i+i', n-i'), where sus = (s, i, n).

• raises Invalid_argument

  if i' < 0 or i' > n.

slice sus i' (Some n') returns the substring (s, i+i', n'), where sus = (s, i, n).

• raises Invalid_argument

  if i' < 0 or n' < 0 or i'+n' >= n.

concat suss returns a string consisting of the concatenation of the substrings. Equivalent to String.concat (List.map to_string suss).

explode sus returns the list of characters of sus, that is, s(i), s(i+1), ..., s(i+n-1) where sus = (s, i, n). Equivalent to String.explode (to_string ss).

is_prefix s1 s2 is true if s1 is a prefix of s2. That is, if there exists a string t such that string s1 ^ t = to_string s2.

compare sus1 sus2 performs lexicographic comparison, using the standard ordering Char.compare on the characters.p Equivalent to, but more efficient than, String.compare (to_string sus1) (to_string sus2).

index sus c returns the index of the first occurrence of c in sus or

• raises Not_found

  otherwise.

index_from sus i c returns the index of the first occurrence of c in sus after the index i.

• raises Not_found

  otherwise.

• raises Invalid_argument

  If i is beyond the range of sus.

It is equivalent to i + index (triml i sus) c.

rindex sus c returns the index of the last occurrence of c in sus or

• raises Not_found

  otherwise.

index_from sus i c returns the index of the last occurrence of c in sus before the index i.

• raises Not_found

  otherwise.

• raises Invalid_argument

  If i is beyond the range of sus.

It is equivalent to rindex (trimr i sus) c.

contains s c tests if character c appears in the substring s.

• since 2.1

dropl p sus drops the longest prefix (left substring) of sus all of whose characters satisfy predicate p. If all characters do, it returns the empty substring (s, i+n, 0) where sus = (s, i, n).

dropr p sus drops the longest suffix (right substring) of sus all of whose characters satisfy predicate p. If all characters do, it returns the empty substring (s, i, 0) where sus = (s, i, n).

takel p sus returns the longest prefix (left substring) of sus all of whose characters satisfy predicate p. That is, if the left-most character does not satisfy p, returns the empty (s, i, 0) where sus = (s, i, n).

taker p sus returns the longest suffix (right substring) of sus all of whose characters satisfy predicate p. That is, if the right-most character satisfies p, returns the empty (s, i+n, 0) where sus = (s, i, n).

Let p be a predicate and xxxxfyyyyfzzzz a string where all characters in xxxx and zzzz satisfy p, and f a character not satisfying p. Then

sus = xxxxfyyyyfzzzz sus = xxxxzzzz ------------------------------------------------------ dropl p sus = fyyyyfzzzz dropr p sus = xxxxfyyyyf takel p sus = xxxx xxxxzzzz taker p sus = zzzz xxxxzzzz

It also holds that concat (takel p sus) (dropl p sus) = string sus concat (dropr p sus) (taker p sus) = string sus

splitl p sus splits sus into a pair (sus1, sus2) of substrings where sus1 is the longest prefix (left substring) all of whose characters satisfy p, and sus2 is the rest. That is, sus2 begins with the leftmost character not satisfying p. Disregarding sideeffects, we have: splitl p sus = (takel p sus, dropl p sus).

splitr p sus splits sus into a pair (sus1, sus2) of substrings where sus2 is the longest suffix (right substring) all of whose characters satisfy p, and sus1 is the rest. That is, sus1 ends with the rightmost character not satisfying p. Disregarding sideeffects, we have: splitr p sus = (dropr p sus, taker p sus)

split_at sus k returns the pair (sus1, sus2) of substrings, where sus1 contains the first k characters of sus, and sus2 contains the rest.

• raises Invalid_argument

  if k < 0 or k > size sus.

span sus1 sus2 returns a substring spanning from the start of sus1 to the end of sus2, provided this is well-defined: sus1 and sus2 must have the same underlying string, and the start of sus1 must not be to the right of the end of sus2; otherwise

• raises Invalid_argument.

More precisely, if base sus1 = (s,i,n) and base sus2 = (s',i',n') and s = s' and i <= i'+n', then base (span sus1 sus2) = (s, i, i'+n'-i). This may be used to compute span, union, and intersection.

translate f sus applies f to every character of sus, from left to right, and returns the concatenation of the results. Equivalent to String.of_list (List.map f (explode sus)).

tokens p sus returns the list of tokens in sus, from left to right, where a token is a non-empty maximal substring of sus not containing any delimiter, and a delimiter is a character satisfying p.

fields p sus returns the list of fields in sus, from left to right, where a field is a (possibly empty) maximal substring of sus not containing any delimiter, and a delimiter is a character satisfying p.

Two tokens may be separated by more than one delimiter, whereas two fields are separated by exactly one delimiter. If the only delimiter is the character '|', then "abc||def" contains two tokens: "abc" and "def" "abc||def" contains three fields: "abc" and "" and "def"

fold_left f e sus folds f over sus from left to right. That is, evaluates f s.[i+n-1] (f ... (f s.[i+1] (f s.[i] e)) ...) tail-recursively, where sus = (s, i, n). Equivalent to List.fold_left f e (explode sus).

As fold_left, but with the index of the element as additional argument

• since 2.3.0

fold_right f e sus folds f over sus from right to left. That is, evaluates f s.[i] (f s.[i+1] (f ... (f s.[i+n-1] e) ...)) tail-recursively, where sus = (s, i, n). Equivalent to List.fold_right f e (explode sus).

As fold_right, but with the index of the element as additional argument

• since 2.3.0

iter f sus applies f to all characters of sus, from left to right. Equivalent to List.iter f (explode sus).

Same as iter, but the function is applied to the index of the element as first argument (counting from 0), and the character itself as second argument.

• since 2.1

removes whitespace from left and right ends of input

split_on_char c ss returns substrings of input ss as divided by c

enum ss returns an enumeration of the characters represented by ss. It does no copying so beweare of mutating the original string.

• since 2.1

print oc ss prints ss to the output channel oc

append_to_buffer buff ss appends the sub string ss to buffer b.