fsplit_rev ?excl ~f l returns Some(x,y) where x is the **reversed** list of the consecutive elements of l that obey the split function f. Note that f is applied to a list of elements and not just an element, so that f can look farther in the list when applied. f l returns Continue if there're more elements to consume, Continue_with(left,right) if there's more elements to consume but we want to choose what goes to the left part and what remains to process (right part), and returns Split(left,right) if the splitting is decided. When f is applied to an empty list, if it returns Continue then the result will be None.

If excl is given, then excl is applied before f is, to check if the splitting should be stopped right away. When the split fails, it returns None.

let fsplit: ( ~?excl: option(list('a) => bool), ~f: split('a), list('a) ) => option((list('a), list('a)))

fsplit ?excl ~f l returns Some(List.rev x, y) if fsplit ?excl ~f l returns Some(x,y), else it returns None.

let id_of_string: ( < mangle : string -> string; .. >, string ) => string

id_of_string ids id returns a mangled version of id, using the method ids#mangle. If you don't need mangling, you may use object method mangle x = x end for ids. However, the name ids also means that your object should have knowledge of all IDs it has issued, in order to avoid collision. This is why id_of_string asks for an object rather than "just a function".

let htmlentities: (~?md: option(bool), string) => string

htmlentities s returns a new string in which html-significant characters have been converted to html entities. For instance, "<Foo&Bar>" is converted to "<Foo&Bar>".

let minimalize_blanks: string => string

minimalize_blanks s returns a copy of s in which the first and last characters are never blank, and two consecutive blanks never happen.

let eat: ('a => bool, list('a)) => list('a)

eat f l returns l where elements satisfying f have been removed, but it stops removing as soon as one element doesn't satisfy f.

let extract_html_attributes: string => list( (string, string) )

Takes some HTML and returns the list of attributes of the first ML tag. tes: Doesn't check the validity of HTML tags or attributes. Doesn't support backslash escaping. Attribute names are delimited by the space and equal characters. Attribute values are either delimited by the double quote or the simple quote character.

let extract_inner_html: string => string

Takes an HTML node and returns the contents of the node. If it's not given a node, it returns something rubbish.

let html_void_elements: StringSet.t

HTML void elements

let @: (list('a), list('a)) => list('a)

Tail-recursive version of Pervasives.(@).

Omd_utils

let debug: bool

let trackfix: bool

let raise: exn => 'a

let warn: (~?we: option(bool), string) => unit

module StringSet

include

type elt = string

type t

let empty: t

let is_empty: t => bool

let mem: (elt, t) => bool

let add: (elt, t) => t

let singleton: elt => t

let remove: (elt, t) => t

let union: (t, t) => t

let inter: (t, t) => t

let diff: (t, t) => t

let compare: (t, t) => int

let equal: (t, t) => bool

let subset: (t, t) => bool

let iter: (elt => unit, t) => unit

let fold: ((elt, 'a) => 'a, t, 'a) => 'a

let for_all: (elt => bool, t) => bool

let exists: (elt => bool, t) => bool

let filter: (elt => bool, t) => t

let partition: (elt => bool, t) => (t, t)

let cardinal: t => int

let elements: t => list(elt)

let min_elt: t => elt

let max_elt: t => elt

let choose: t => elt

let split: (elt, t) => (t, bool, t)

let find: (elt, t) => elt

let of_list: list(elt) => t