# Module Topkg.String

    module String: sig .. end

Strings.

## String additions

    include String

    val head : string -> char option

`head s` if `Some s.[0]` if `s <> ""` and `None` otherwise.

## Predicates

    val is_prefix : affix:string -> string -> bool

`is_prefix ~affix s` is `true` iff `affix.[i] = s.[i]` for all indices `i` of `affix`.

    val is_suffix : affix:string -> string -> bool

`is_suffix ~affix s` is true iff `affix.[n - i] = s.[m - i]` for all indices `i` of `affix` with `n = String.length affix - 1` and `m =
String.length s - 1`.

    val for_all : (char -> bool) -> string -> bool

`for_all p s` is `true` iff for all indices `i` of `s`, `p s.[i]
= true`.

    val exists : (char -> bool) -> string -> bool

`exists p s` is `true` iff there exists an index `i` of `s` with `p s.[i] = true`.

## Extracting substrings

    val with_index_range : ?first:int -> ?last:int -> string -> string

`with_index_range ~first ~last s` are the consecutive bytes of `s` whose indices exist in the range [`first`;`last`].

`first` defaults to `0` and last to `String.length s - 1`.

Note that both `first` and `last` can be any integer. If `first > last` the interval is empty and the empty string is returned.

    val cut : ?rev:bool -> sep:char -> string -> (string * string) option

`cut ~sep s` is either the pair `Some (l,r)` of the two (possibly empty) substrings of `s` that are delimited by the first match of the separator character `sep` or `None` if `sep` can't be matched in `s`. Matching starts from the beginning of `s` (`rev` is `false`, default) or the end (`rev` is `true`).

The invariant `l ^ (String.make 1 sep) ^ r = s` holds.

    val cuts : ?empty:bool -> sep:char -> string -> string list

`cuts ~sep s` is the list of all substring of `s` that are delimited by matches of `sep`. Empty substrings are ommited in the list if `empty` is `falsee` (defaults to `true`). The invariant `String.concat (String.make 1 sep) (split ~sep s) = s` holds.

## Parsing version strings

    val parse_version : string -> (int * int * int * string option) option

`parse_version` parses version strings of the form:

    "[v]major.minor[.patchlevel][+additional-info]"

into `(major, minor, patch, additiona_info)` tuples.

    val drop_initial_v : string -> string

`drop_initial_v s` drops a leading `'v'` or `'V'` from `s`.