<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<link rel="Start" href="index.html">
<link rel="next" href="Pdfio.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="Pdfutil" rel="Chapter" href="Pdfutil.html">
<link title="Pdfio" rel="Chapter" href="Pdfio.html">
<link title="Pdftransform" rel="Chapter" href="Pdftransform.html">
<link title="Pdfunits" rel="Chapter" href="Pdfunits.html">
<link title="Pdfpaper" rel="Chapter" href="Pdfpaper.html">
<link title="Pdf" rel="Chapter" href="Pdf.html">
<link title="Pdfcrypt" rel="Chapter" href="Pdfcrypt.html">
<link title="Pdfflate" rel="Chapter" href="Pdfflate.html">
<link title="Pdfcodec" rel="Chapter" href="Pdfcodec.html">
<link title="Pdfwrite" rel="Chapter" href="Pdfwrite.html">
<link title="Pdfgenlex" rel="Chapter" href="Pdfgenlex.html">
<link title="Pdfread" rel="Chapter" href="Pdfread.html">
<link title="Pdfjpeg" rel="Chapter" href="Pdfjpeg.html">
<link title="Pdfops" rel="Chapter" href="Pdfops.html">
<link title="Pdfdest" rel="Chapter" href="Pdfdest.html">
<link title="Pdfmarks" rel="Chapter" href="Pdfmarks.html">
<link title="Pdfpagelabels" rel="Chapter" href="Pdfpagelabels.html">
<link title="Pdfpage" rel="Chapter" href="Pdfpage.html">
<link title="Pdfannot" rel="Chapter" href="Pdfannot.html">
<link title="Pdffun" rel="Chapter" href="Pdffun.html">
<link title="Pdfspace" rel="Chapter" href="Pdfspace.html">
<link title="Pdfimage" rel="Chapter" href="Pdfimage.html">
<link title="Pdfafm" rel="Chapter" href="Pdfafm.html">
<link title="Pdfafmdata" rel="Chapter" href="Pdfafmdata.html">
<link title="Pdfglyphlist" rel="Chapter" href="Pdfglyphlist.html">
<link title="Pdftext" rel="Chapter" href="Pdftext.html">
<link title="Pdfstandard14" rel="Chapter" href="Pdfstandard14.html">
<link title="Pdfgraphics" rel="Chapter" href="Pdfgraphics.html">
<link title="Pdfshapes" rel="Chapter" href="Pdfshapes.html">
<link title="Pdfdate" rel="Chapter" href="Pdfdate.html">
<link title="Pdfocg" rel="Chapter" href="Pdfocg.html">
<link title="Pdfcff" rel="Chapter" href="Pdfcff.html">
<link title="Pdftype1" rel="Chapter" href="Pdftype1.html">
<link title="Pdftruetype" rel="Chapter" href="Pdftruetype.html">
<link title="Pdftype0" rel="Chapter" href="Pdftype0.html">
<link title="Pdfmerge" rel="Chapter" href="Pdfmerge.html"><link title="Debug Printing" rel="Section" href="#2_DebugPrinting">
<link title="Strings" rel="Section" href="#2_Strings">
<link title="Lists" rel="Section" href="#2_Lists">
<link title="32 and 64 bit integers" rel="Section" href="#2_32and64bitintegers">
<link title="Association lists" rel="Section" href="#2_Associationlists">
<link title="References" rel="Section" href="#2_References">
<link title="Geometry" rel="Section" href="#2_Geometry">
<link title="Numbers" rel="Section" href="#2_Numbers">
<link title="Options" rel="Section" href="#2_Options">
<link title="Hash tables" rel="Section" href="#2_Hashtables">
<link title="Trees" rel="Section" href="#2_Trees">
<link title="Arrays" rel="Section" href="#2_Arrays">
<link title="Control flow" rel="Section" href="#2_Controlflow">
<link title="Tuples" rel="Section" href="#2_Tuples">
<link title="Equality" rel="Section" href="#2_Equality">
<link title="Logic" rel="Section" href="#2_Logic">
<link title="Boxes" rel="Section" href="#2_Boxes">
<link title="Filenames" rel="Section" href="#2_Filenames">
<link title="Roman numerals" rel="Section" href="#2_Romannumerals">
<title>Pdfutil</title>
</head>
<body>
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
<a class="post" href="Pdfio.html" title="Pdfio">Next</a>
</div>
<h1>Module <a href="type_Pdfutil.html">Pdfutil</a></h1>
<pre><span class="keyword">module</span> Pdfutil: <code class="code">sig</code> <a href="Pdfutil.html">..</a> <code class="code">end</code></pre><div class="info module top">
General Functions. Typically one will <code class="code">open Pdfutil</code> and not use <code class="code">open</code> elsewhere.<br>
</div>
<hr width="100%">
<br>
<h2 id="2_DebugPrinting">Debug Printing</h2><br>
<pre><span id="VALflprint"><span class="keyword">val</span> flprint</span> : <code class="type">string -> unit</code></pre><div class="info ">
Print a string and flush standard output.<br>
</div>
<pre><span id="VALprint_floats"><span class="keyword">val</span> print_floats</span> : <code class="type">float list -> unit</code></pre><div class="info ">
Print a list of floating point numbers separated by spaces.<br>
</div>
<pre><span id="VALprint_ints"><span class="keyword">val</span> print_ints</span> : <code class="type">int list -> unit</code></pre><div class="info ">
Print a list of integers separated by spaces<br>
</div>
<pre><span id="VALprint_int32s"><span class="keyword">val</span> print_int32s</span> : <code class="type">int32 list -> unit</code></pre><div class="info ">
Print a list of <code class="code">int32</code>s separated by spaces<br>
</div>
<br>
<h2 id="2_Strings">Strings</h2><br>
<pre><span id="VALfirstchar"><span class="keyword">val</span> firstchar</span> : <code class="type">string -> char option</code></pre><div class="info ">
Return the first character of a string, should it have one. Otherwise return
<code class="code">None</code>.<br>
</div>
<pre><span id="VALlastchar"><span class="keyword">val</span> lastchar</span> : <code class="type">string -> char option</code></pre><div class="info ">
Return the first character of a string, should it have one. Otherwise return
<code class="code">None</code>.<br>
</div>
<pre><span id="VALexplode"><span class="keyword">val</span> explode</span> : <code class="type">string -> char list</code></pre><div class="info ">
List of characters representing a string.<br>
</div>
<pre><span id="VALimplode"><span class="keyword">val</span> implode</span> : <code class="type">char list -> string</code></pre><div class="info ">
String representing a list of characters. Fails if list is longer than
<code class="code">Sys.max_string_length</code>.<br>
</div>
<pre><span id="VALstring_of_char"><span class="keyword">val</span> string_of_char</span> : <code class="type">char -> string</code></pre><div class="info ">
Make a string from a character.<br>
</div>
<pre><span id="VALstring_replace_all"><span class="keyword">val</span> string_replace_all</span> : <code class="type">string -> string -> string -> string</code></pre><div class="info ">
Calling <code class="code">string_replace_all x x' s</code> replaces all instances of <code class="code">x</code> with <code class="code">x'</code>
in <code class="code">s</code>, returning a new string.<br>
</div>
<br>
<h2 id="2_Lists">Lists</h2><br>
<pre><span id="VALhd"><span class="keyword">val</span> hd</span> : <code class="type">'a list -> 'a</code></pre>
<pre><span id="VALtl"><span class="keyword">val</span> tl</span> : <code class="type">'a list -> 'a list</code></pre>
<pre><span id="VALrev"><span class="keyword">val</span> rev</span> : <code class="type">'a list -> 'a list</code></pre>
<pre><span id="VALiter"><span class="keyword">val</span> iter</span> : <code class="type">('a -> unit) -> 'a list -> unit</code></pre>
<pre><span id="VALiter2"><span class="keyword">val</span> iter2</span> : <code class="type">('a -> 'b -> unit) -> 'a list -> 'b list -> unit</code></pre>
<pre><span id="VALiter3"><span class="keyword">val</span> iter3</span> : <code class="type">('a -> 'b -> 'c -> unit) -> 'a list -> 'b list -> 'c list -> unit</code></pre>
<pre><span id="VALappend"><span class="keyword">val</span> append</span> : <code class="type">'a list -> 'a list -> 'a list</code></pre>
<pre><span id="VAL(@)"><span class="keyword">val</span> (@)</span> : <code class="type">'a list -> 'a list -> 'a list</code></pre>
<pre><span id="VALflatten"><span class="keyword">val</span> flatten</span> : <code class="type">'a list list -> 'a list</code></pre>
<pre><span id="VALrev_map"><span class="keyword">val</span> rev_map</span> : <code class="type">('a -> 'b) -> 'a list -> 'b list</code></pre>
<pre><span id="VALmap"><span class="keyword">val</span> map</span> : <code class="type">('a -> 'b) -> 'a list -> 'b list</code></pre>
<pre><span id="VALmap2"><span class="keyword">val</span> map2</span> : <code class="type">('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list</code></pre>
<pre><span id="VALsplit"><span class="keyword">val</span> split</span> : <code class="type">('a * 'b) list -> 'a list * 'b list</code></pre>
<pre><span id="VALsplit3"><span class="keyword">val</span> split3</span> : <code class="type">('a * 'b * 'c) list -> 'a list * 'b list * 'c list</code></pre>
<pre><span id="VALsplit5"><span class="keyword">val</span> split5</span> : <code class="type">('a * 'b * 'c * 'd * 'e) list -><br> 'a list * 'b list * 'c list * 'd list * 'e list</code></pre>
<pre><span id="VALsplit8"><span class="keyword">val</span> split8</span> : <code class="type">('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h) list -><br> 'a list * 'b list * 'c list * 'd list * 'e list * 'f list * 'g list * 'h list</code></pre>
<pre><span id="VALcombine"><span class="keyword">val</span> combine</span> : <code class="type">'a list -> 'b list -> ('a * 'b) list</code></pre>
<pre><span id="VALcombine3"><span class="keyword">val</span> combine3</span> : <code class="type">'a list -> 'b list -> 'c list -> ('a * 'b * 'c) list</code></pre>
<pre><span id="VALfold_left"><span class="keyword">val</span> fold_left</span> : <code class="type">('a -> 'b -> 'a) -> 'a -> 'b list -> 'a</code></pre>
<pre><span id="VALfold_right"><span class="keyword">val</span> fold_right</span> : <code class="type">('a -> 'b -> 'b) -> 'a list -> 'b -> 'b</code></pre>
<pre><span id="VALlength"><span class="keyword">val</span> length</span> : <code class="type">'a list -> int</code></pre>
<pre><span id="VALsort"><span class="keyword">val</span> sort</span> : <code class="type">('a -> 'a -> int) -> 'a list -> 'a list</code></pre><div class="info ">
Tail-recursive versions of list functions (and some simple variations). See
<code class="code">Pervasives</code> for documentation.<br>
</div>
<pre><span id="VALcumulative_sum"><span class="keyword">val</span> cumulative_sum</span> : <code class="type">int -> int list -> int list</code></pre><div class="info ">
Cumulative sum of a list given an initial value. For example, <code class="code">cumulative_sum 1 [2; 3; 4]</code> is <code class="code">[3; 6; 10]</code><br>
</div>
<pre><span id="VALlcount"><span class="keyword">val</span> lcount</span> : <code class="type">('a -> bool) -> 'a list -> int</code></pre><div class="info ">
Count the number of elements in a list for which predicate is true.<br>
</div>
<pre><span id="VALlosenones"><span class="keyword">val</span> losenones</span> : <code class="type">'a option list -> 'a list</code></pre><div class="info ">
Return just the non-<code class="code">None</code> elements of an <code class="code">'a option list</code><br>
</div>
<pre><span id="VALoption_map"><span class="keyword">val</span> option_map</span> : <code class="type">('a -> 'b option) -> 'a list -> 'b list</code></pre><div class="info ">
Map with a function returning an <code class="code">option</code>, dropping all <code class="code">None</code> results and
extracting all <code class="code">Some</code> ones.<br>
</div>
<pre><span id="VALoption_map2"><span class="keyword">val</span> option_map2</span> : <code class="type">('a -> 'b -> 'c option) -> 'a list -> 'b list -> 'c list</code></pre><div class="info ">
Like <code class="code">option_map</code> but with a two-argument function and two (equal-length)
input lists. Uses <code class="code">List.rev_map2</code> internally and may raise the same exception.<br>
</div>
<pre><span id="VALmem"><span class="keyword">val</span> mem</span> : <code class="type">'a -> 'a list -> bool</code></pre><div class="info ">
Synonym for <code class="code">List.mem</code>.<br>
</div>
<pre><span id="VALrev_map3"><span class="keyword">val</span> rev_map3</span> : <code class="type">('a -> 'b -> 'c -> 'd) -> 'a list -> 'b list -> 'c list -> 'd list</code></pre><div class="info ">
Similar to <code class="code">rev_map</code>, but 3 arguments.<br>
</div>
<pre><span id="VALmap3"><span class="keyword">val</span> map3</span> : <code class="type">('a -> 'b -> 'c -> 'd) -> 'a list -> 'b list -> 'c list -> 'd list</code></pre><div class="info ">
Similar to <code class="code">map2</code>, but 3 arguments.<br>
</div>
<pre><span id="VALrev_map4"><span class="keyword">val</span> rev_map4</span> : <code class="type">('a -> 'b -> 'c -> 'd -> 'e) -><br> 'a list -> 'b list -> 'c list -> 'd list -> 'e list</code></pre><div class="info ">
Similar to <code class="code">rev_map</code>, but 4 arguments.<br>
</div>
<pre><span id="VALmap4"><span class="keyword">val</span> map4</span> : <code class="type">('a -> 'b -> 'c -> 'd -> 'e) -><br> 'a list -> 'b list -> 'c list -> 'd list -> 'e list</code></pre><div class="info ">
Similar to <code class="code">map2</code>, but 4 arguments.<br>
</div>
<pre><span id="VALrev_map5"><span class="keyword">val</span> rev_map5</span> : <code class="type">('a -> 'b -> 'c -> 'd -> 'e -> 'f) -><br> 'a list -> 'b list -> 'c list -> 'd list -> 'e list -> 'f list</code></pre><div class="info ">
Similar to <code class="code">rev_map</code>, but 5 arguments.<br>
</div>
<pre><span id="VALmap5"><span class="keyword">val</span> map5</span> : <code class="type">('a -> 'b -> 'c -> 'd -> 'e -> 'f) -><br> 'a list -> 'b list -> 'c list -> 'd list -> 'e list -> 'f list</code></pre><div class="info ">
Similar to <code class="code">map2</code>, but 5 arguments.<br>
</div>
<pre><span id="VALtake"><span class="keyword">val</span> take</span> : <code class="type">'a list -> int -> 'a list</code></pre><div class="info ">
<code class="code">take l n</code> takes <code class="code">n</code> elements from the list raising <code class="code">Invalid_argument</code> if
there are not enough elements to take or if n < 0.<br>
</div>
<pre><span id="VALtake'"><span class="keyword">val</span> take'</span> : <code class="type">int -> 'a list -> 'a list</code></pre><div class="info ">
The same as <code class="code">take</code>, but with the arguments reversed.<br>
</div>
<pre><span id="VALdrop"><span class="keyword">val</span> drop</span> : <code class="type">'a list -> int -> 'a list</code></pre><div class="info ">
<code class="code">drop l n</code> drops <code class="code">n</code> elements from the list raising <code class="code">Invalid_argument</code> if <code class="code">n</code>
< 0 or there are not enough elements.<br>
</div>
<pre><span id="VALdrop'"><span class="keyword">val</span> drop'</span> : <code class="type">int -> 'a list -> 'a list</code></pre><div class="info ">
Same as <code class="code">drop</code>, but with the arguments reversed.<br>
</div>
<pre><span id="VALtakewhile"><span class="keyword">val</span> takewhile</span> : <code class="type">('a -> bool) -> 'a list -> 'a list</code></pre><div class="info ">
Take elements from a list while a given predicate is true, returning them in order.<br>
</div>
<pre><span id="VALtakewhile_reverse"><span class="keyword">val</span> takewhile_reverse</span> : <code class="type">('a -> bool) -> 'a list -> 'a list</code></pre><div class="info ">
The same as <code class="code">takewhile</code>, but the list is returned in reverse order.<br>
</div>
<pre><span id="VALdropwhile"><span class="keyword">val</span> dropwhile</span> : <code class="type">('a -> bool) -> 'a list -> 'a list</code></pre><div class="info ">
Drop elements from a list while a given predicate is true.<br>
</div>
<pre><span id="VALcleave"><span class="keyword">val</span> cleave</span> : <code class="type">'a list -> int -> 'a list * 'a list</code></pre><div class="info ">
<code class="code">cleave l n</code> splits <code class="code">l</code> into two parts, returned as a tuple. The first
contains the first <code class="code">n</code> elements, the second the remainder.
Order is preserved. <code class="code">Invalid_argument</code> is raised on negative argument or not
enough elements in list.<br>
</div>
<pre><span id="VALcleavewhile"><span class="keyword">val</span> cleavewhile</span> : <code class="type">('a -> bool) -> 'a list -> 'a list * 'a list</code></pre><div class="info ">
Same, but split point controlled by a predicate, which is true for elements
in the first returned list. e.g <code class="code">cleavewhile even [2;4;5;6]</code> produces <code class="code">([2;4], [5;6])</code><br>
</div>
<pre><span id="VALcleavewhile_unordered"><span class="keyword">val</span> cleavewhile_unordered</span> : <code class="type">('a -> bool) -> 'a list -> 'a list * 'a list</code></pre><div class="info ">
The same as <code class="code">cleavewhile</code>, but the output lists are each unordered.<br>
</div>
<pre><span id="VALisolate"><span class="keyword">val</span> isolate</span> : <code class="type">('a -> bool) -> ('a -> bool) -> 'a list -> 'a list</code></pre><div class="info ">
<code class="code">isolate p p' l</code> isolate a central section of a list <code class="code">l</code>, from the first
element after the elements for which predicate <code class="code">p</code> is true, to the element
before <code class="code">p'</code> is first true.<br>
</div>
<pre><span id="VALinterleave"><span class="keyword">val</span> interleave</span> : <code class="type">'a -> 'a list -> 'a list</code></pre><div class="info ">
Interleave an element among a list, so that <code class="code">interleave 0 [1; 2; 3]</code>
yields <code class="code">[1; 0; 2; 0; 3]</code>. An empty or singleton list is unchanged.<br>
</div>
<pre><span id="VALinterleave_lists"><span class="keyword">val</span> interleave_lists</span> : <code class="type">'a list -> 'a list -> 'a list</code></pre><div class="info ">
Interleave two equal-length lists, taking from the first list first.<br>
</div>
<pre><span id="VALcollate"><span class="keyword">val</span> collate</span> : <code class="type">('a -> 'a -> int) -> 'a list -> 'a list list</code></pre><div class="info ">
Collate a list into a list of lists based upon a comparison function by which
it has already been sorted. e.g <code class="code">collate compare [1; 2; 2; 3; 3]</code> calculates
<code class="code">[[1]; [2;2]; [3;3]]</code>.<br>
</div>
<pre><span id="VALmap_lol"><span class="keyword">val</span> map_lol</span> : <code class="type">('a -> 'b) -> 'a list list -> 'b list list</code></pre><div class="info ">
Map on lists of lists. So <code class="code">map_lol f</code> is <code class="code">map (map f)</code>.<br>
</div>
<pre><span id="VALpairs"><span class="keyword">val</span> pairs</span> : <code class="type">'a list -> ('a * 'a) list</code></pre><div class="info ">
Produce a list of overlapping pairs of elements in a list in order, producing
the empty list if on singleton input. e.g <code class="code">pairs [1; 2; 3]</code> is <code class="code">[(1, 2); (2,
3)]</code>.<br>
</div>
<pre><span id="VALmem'"><span class="keyword">val</span> mem'</span> : <code class="type">'a list -> 'a -> bool</code></pre><div class="info ">
<code class="code">List.mem</code> with arguments reversed.<br>
</div>
<pre><span id="VALsetify"><span class="keyword">val</span> setify</span> : <code class="type">'a list -> 'a list</code></pre><div class="info ">
Remove duplicates from a list.<br>
</div>
<pre><span id="VALsetify_preserving_order"><span class="keyword">val</span> setify_preserving_order</span> : <code class="type">'a list -> 'a list</code></pre><div class="info ">
Same as <code class="code">setify</code>, but preserve order.<br>
</div>
<pre><span id="VALsetminus"><span class="keyword">val</span> setminus</span> : <code class="type">'a list -> 'a list -> 'a list</code></pre><div class="info ">
The set <code class="code">setminus a b</code> contains all those elements which are in <code class="code">a</code> but are
do not appear in <code class="code">b</code>.<br>
</div>
<pre><span id="VALsetminus_preserving_order"><span class="keyword">val</span> setminus_preserving_order</span> : <code class="type">'a list -> 'a list -> 'a list</code></pre><div class="info ">
The same, but preserving order<br>
</div>
<pre><span id="VALheads"><span class="keyword">val</span> heads</span> : <code class="type">'a list list -> 'a list</code></pre><div class="info ">
Return a list of the heads of a list of lists, each of which has at least
one element, preserving order.<br>
</div>
<pre><span id="VALtails"><span class="keyword">val</span> tails</span> : <code class="type">'a list list -> 'a list list</code></pre><div class="info ">
Ditto, tails.<br>
</div>
<pre><span id="VALzipn"><span class="keyword">val</span> zipn</span> : <code class="type">'a list list -> 'a list list</code></pre><div class="info ">
Take a list of lists of equal length, and turn into a list of lists, the
first containing all the first elements of the original lists, the second the
second, and so on.<br>
</div>
<pre><span id="VALcouple"><span class="keyword">val</span> couple</span> : <code class="type">('a -> 'a -> 'b) -> 'a list -> 'b list</code></pre><div class="info ">
Couple the elements of a list <code class="code">l</code> using given function. For instance,
<code class="code">couple ( + ) [[1; 3; 5]]</code> is <code class="code">[4; 8]</code>. The two elements are applied to <code class="code">f</code> in
the order in which they appear in the input list.<br>
</div>
<pre><span id="VALcouple_ext"><span class="keyword">val</span> couple_ext</span> : <code class="type">('a -> 'a -> 'b) -> ('a -> 'b) -> 'a list -> 'b list</code></pre><div class="info ">
As <code class="code">couple</code>, but an extra unary function is applied to any last (odd) element.<br>
</div>
<pre><span id="VALcouple_reduce"><span class="keyword">val</span> couple_reduce</span> : <code class="type">('a -> 'a -> 'a) -> 'a list -> 'a</code></pre><div class="info ">
Apply <code class="code">couple</code> repeatedly until only one element remains. Return that
element.<br>
</div>
<pre><span id="VALpair"><span class="keyword">val</span> pair</span> : <code class="type">('a -> 'a -> 'a) -> 'a list -> 'a list</code></pre><div class="info ">
A similar function to <code class="code">couple</code>, but the coupling is non-overlapping. So
<code class="code">pair ( + ) [1; 2; 3; 4]</code> is <code class="code">3; 7</code>.<br>
</div>
<pre><span id="VALpair_ext"><span class="keyword">val</span> pair_ext</span> : <code class="type">('a -> 'a -> 'b) -> ('a -> 'b) -> 'a list -> 'b list</code></pre><div class="info ">
A version of <code class="code">pair</code> which adds a unary function for the singleton, much
like <code class="code">couple_ext</code>.<br>
</div>
<pre><span id="VALpair_reduce"><span class="keyword">val</span> pair_reduce</span> : <code class="type">('a -> 'a -> 'a) -> 'a list -> 'a</code></pre><div class="info ">
As <code class="code">couple_reduce</code> is to <code class="code">couple</code>, so <code class="code">pair_reduce</code> is to <code class="code">pair</code>.<br>
</div>
<pre><span id="VALkeep"><span class="keyword">val</span> keep</span> : <code class="type">('a -> bool) -> 'a list -> 'a list</code></pre>
<pre><span id="VALlose"><span class="keyword">val</span> lose</span> : <code class="type">('a -> bool) -> 'a list -> 'a list</code></pre><div class="info ">
<code class="code">List.filter</code> has a confusing name, so we define <code class="code">keep</code> and <code class="code">lose</code> to avoid
error. <code class="code">keep</code> keeps all those matching the predicate, <code class="code">lose</code> loses all thos
matching a predicate.<br>
</div>
<pre><span id="VALmany"><span class="keyword">val</span> many</span> : <code class="type">'a -> int -> 'a list</code></pre><div class="info ">
<code class="code">many x n</code> makes a list of length <code class="code">n</code> with each element equal to <code class="code">x</code>.<br>
</div>
<pre><span id="VALmanyunique"><span class="keyword">val</span> manyunique</span> : <code class="type">(unit -> 'a) -> int -> 'a list</code></pre><div class="info ">
A version where we need to apply unit each time, for instance when producing
a list of random numbers. Result is ordered.<br>
</div>
<pre><span id="VALsplitinto"><span class="keyword">val</span> splitinto</span> : <code class="type">int -> 'a list -> 'a list list</code></pre><div class="info ">
Split a list into some lists of length <code class="code">n</code> (and possibly a final one of
length <code class="code">< n</code>), preserving order.<br>
</div>
<pre><span id="VALsplitinto_small"><span class="keyword">val</span> splitinto_small</span> : <code class="type">int -> 'a list -> 'a list list</code></pre><div class="info ">
Non-tail recursive version of splitinto, for use only when <code class="code">n</code> is small and fixed.<br>
</div>
<pre><span id="VALsplitat"><span class="keyword">val</span> splitat</span> : <code class="type">int list -> 'a list -> 'a list list</code></pre><div class="info ">
Split a list at the given positions. Point 1 means after the first element<br>
</div>
<pre><span id="VALselect"><span class="keyword">val</span> select</span> : <code class="type">int -> 'a list -> 'a</code></pre><div class="info ">
Select the nth element in a list (first is element 1). Raises
<code class="code">Invalid_argument</code> if the number is out-of-range.<br>
</div>
<pre><span id="VALreplace_number"><span class="keyword">val</span> replace_number</span> : <code class="type">int -> 'a -> 'a list -> 'a list</code></pre><div class="info ">
<code class="code">replace n x xs</code> replaces the <code class="code">n</code>th element of the list <code class="code">xs</code> with <code class="code">x</code> (the first is element 1)<br>
</div>
<pre><span id="VALisnull"><span class="keyword">val</span> isnull</span> : <code class="type">'a list -> bool</code></pre>
<pre><span id="VALnotnull"><span class="keyword">val</span> notnull</span> : <code class="type">'a list -> bool</code></pre><div class="info ">
Predicates on the nullness of a list.<br>
</div>
<pre><span id="VALlast"><span class="keyword">val</span> last</span> : <code class="type">'a list -> 'a</code></pre><div class="info ">
Find the last element of a list. Raises <code class="code">Invalid_argument</code> on empty list.<br>
</div>
<pre><span id="VALall_but_last"><span class="keyword">val</span> all_but_last</span> : <code class="type">'a list -> 'a list</code></pre><div class="info ">
Produce a list containing all but the last element of a list. For the empty
list, returns the empty list.<br>
</div>
<pre><span id="VALextremes"><span class="keyword">val</span> extremes</span> : <code class="type">'a list -> 'a * 'a</code></pre><div class="info ">
Find the first and last element of a list. If the list has one element, that
is returned twice. If it has no elements, raise <code class="code">Invalid_argument</code>.<br>
</div>
<pre><span id="VALextremes_and_middle"><span class="keyword">val</span> extremes_and_middle</span> : <code class="type">'a list -> 'a * 'a list * 'a</code></pre><div class="info ">
Return the first, middle and last elements of a list which has length at
least two. Otherwise, raise <code class="code">Invalid_argument</code>.<br>
</div>
<pre><span id="VALilist"><span class="keyword">val</span> ilist</span> : <code class="type">int -> int -> int list</code></pre><div class="info ">
<code class="code">ilist 2 5</code> returns <code class="code">[2; 3; 4; 5]</code>. However, <code class="code">ilist 5 2</code> raises <code class="code">Invalid_argument</code>.<br>
</div>
<pre><span id="VALilist_null"><span class="keyword">val</span> ilist_null</span> : <code class="type">int -> int -> int list</code></pre><div class="info ">
Same as <code class="code">ilist</code>, but return the empty list for <code class="code">ilist x x</code> rather than <code class="code">[x]</code><br>
</div>
<pre><span id="VALilist_fail_null"><span class="keyword">val</span> ilist_fail_null</span> : <code class="type">int -> int -> int list</code></pre><div class="info ">
Same as <code class="code">ilist_null</code>, but return empty list if start <code class="code">></code> end, instead of failing<br>
</div>
<pre><span id="VALindx"><span class="keyword">val</span> indx</span> : <code class="type">'a list -> int list</code></pre><div class="info ">
<code class="code">indx l</code> returns <code class="code">[1; 2; 3]</code> if <code class="code">l</code> has length 3, for example.<br>
</div>
<pre><span id="VALindx0"><span class="keyword">val</span> indx0</span> : <code class="type">'a list -> int list</code></pre><div class="info ">
Same as <code class="code">indx</code>, but 0-based.<br>
</div>
<pre><span id="VALindxn"><span class="keyword">val</span> indxn</span> : <code class="type">int -> 'a list -> int list</code></pre><div class="info ">
Same as <code class="code">indx</code>, but n-based.<br>
</div>
<pre><span id="VALdrop_evens"><span class="keyword">val</span> drop_evens</span> : <code class="type">'a list -> 'a list</code></pre><div class="info ">
Remove the second, fourth etc. elements from a list, saving the last element
(if of even length) e.g <code class="code">drop_evens [1; 2; 3; 4; 5; 6]</code> is <code class="code">[1; 3; 5; 6]</code>.<br>
</div>
<pre><span id="VALreally_drop_evens"><span class="keyword">val</span> really_drop_evens</span> : <code class="type">'a list -> 'a list</code></pre><div class="info ">
Same as <code class="code">drop_evens</code>, but don't save the last element.<br>
</div>
<pre><span id="VALdrop_odds"><span class="keyword">val</span> drop_odds</span> : <code class="type">'a list -> 'a list</code></pre><div class="info ">
Remove the first, third etc. The last odd element is not saved. e.g <code class="code">drop_odds
[1;2;3;4;5;6;7]</code> is <code class="code">[2;4;6]</code>.<br>
</div>
<pre><span id="VALtail_no_fail"><span class="keyword">val</span> tail_no_fail</span> : <code class="type">'a list -> 'a list</code></pre><div class="info ">
Like <code class="code">List.tl</code> but <code class="code">[]</code> yields <code class="code">[]</code>.<br>
</div>
<pre><span id="VAL(@@)"><span class="keyword">val</span> (@@)</span> : <code class="type">'a list -> 'a list -> 'a list</code></pre><div class="info ">
Append with reversed arguments.<br>
</div>
<pre><span id="VALreplaceinlist"><span class="keyword">val</span> replaceinlist</span> : <code class="type">('a -> bool) -> 'a -> 'a list -> 'a list</code></pre><div class="info ">
<code class="code">replaceinlist f x l</code> replaces any element of <code class="code">l</code> for which <code class="code">f l</code> is true
with <code class="code">x</code>.<br>
</div>
<pre><span id="VALindex"><span class="keyword">val</span> index</span> : <code class="type">('a -> bool) -> 'a list -> int</code></pre><div class="info ">
Find the position of the first element matching a predicate. The first
element is number one. Fails with <code class="code">Not_found</code> if no element matches the
predicate.<br>
</div>
<pre><span id="VALsplit_around"><span class="keyword">val</span> split_around</span> : <code class="type">('a -> bool) -> 'a list -> 'a list list</code></pre><div class="info ">
Split a list into a list of lists at every point where a predicate is true<br>
</div>
<br>
<h2 id="2_32and64bitintegers">32 and 64 bit integers</h2><br>
<pre><span id="VALi32ofi"><span class="keyword">val</span> i32ofi</span> : <code class="type">int -> int32</code></pre>
<pre><span id="VALi32toi"><span class="keyword">val</span> i32toi</span> : <code class="type">int32 -> int</code></pre>
<pre><span id="VALi32tof"><span class="keyword">val</span> i32tof</span> : <code class="type">int32 -> float</code></pre>
<pre><span id="VALi32add"><span class="keyword">val</span> i32add</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALi32sub"><span class="keyword">val</span> i32sub</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALi32div"><span class="keyword">val</span> i32div</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALi32mul"><span class="keyword">val</span> i32mul</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALlsr32"><span class="keyword">val</span> lsr32</span> : <code class="type">int32 -> int -> int32</code></pre>
<pre><span id="VALlsl32"><span class="keyword">val</span> lsl32</span> : <code class="type">int32 -> int -> int32</code></pre>
<pre><span id="VALlor32"><span class="keyword">val</span> lor32</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALland32"><span class="keyword">val</span> land32</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALlnot32"><span class="keyword">val</span> lnot32</span> : <code class="type">int32 -> int32</code></pre>
<pre><span id="VALlxor32"><span class="keyword">val</span> lxor32</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALi32succ"><span class="keyword">val</span> i32succ</span> : <code class="type">int32 -> int32</code></pre>
<pre><span id="VALi32pred"><span class="keyword">val</span> i32pred</span> : <code class="type">int32 -> int32</code></pre>
<pre><span id="VALi32max"><span class="keyword">val</span> i32max</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALi32min"><span class="keyword">val</span> i32min</span> : <code class="type">int32 -> int32 -> int32</code></pre>
<pre><span id="VALi64ofi"><span class="keyword">val</span> i64ofi</span> : <code class="type">int -> int64</code></pre>
<pre><span id="VALi64toi"><span class="keyword">val</span> i64toi</span> : <code class="type">int64 -> int</code></pre>
<pre><span id="VALi64tof"><span class="keyword">val</span> i64tof</span> : <code class="type">int64 -> float</code></pre>
<pre><span id="VALi64add"><span class="keyword">val</span> i64add</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALi64sub"><span class="keyword">val</span> i64sub</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALi64div"><span class="keyword">val</span> i64div</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALi64mul"><span class="keyword">val</span> i64mul</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALlsr64"><span class="keyword">val</span> lsr64</span> : <code class="type">int64 -> int -> int64</code></pre>
<pre><span id="VALlsl64"><span class="keyword">val</span> lsl64</span> : <code class="type">int64 -> int -> int64</code></pre>
<pre><span id="VALlor64"><span class="keyword">val</span> lor64</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALland64"><span class="keyword">val</span> land64</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALlnot64"><span class="keyword">val</span> lnot64</span> : <code class="type">int64 -> int64</code></pre>
<pre><span id="VALlxor64"><span class="keyword">val</span> lxor64</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALi64succ"><span class="keyword">val</span> i64succ</span> : <code class="type">int64 -> int64</code></pre>
<pre><span id="VALi64pred"><span class="keyword">val</span> i64pred</span> : <code class="type">int64 -> int64</code></pre>
<pre><span id="VALi64max"><span class="keyword">val</span> i64max</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALi64min"><span class="keyword">val</span> i64min</span> : <code class="type">int64 -> int64 -> int64</code></pre>
<pre><span id="VALi32ofi64"><span class="keyword">val</span> i32ofi64</span> : <code class="type">int64 -> int32</code></pre>
<pre><span id="VALi64ofi32"><span class="keyword">val</span> i64ofi32</span> : <code class="type">int32 -> int64</code></pre><div class="info ">
Shortened names for functions from <code class="code">Int32</code> and <code class="code">Int64</code>.<br>
</div>
<br>
<h2 id="2_Associationlists">Association lists</h2><br>
<pre><span id="VALlookup"><span class="keyword">val</span> lookup</span> : <code class="type">'a -> ('a * 'b) list -> 'b option</code></pre><div class="info ">
<code class="code">lookup x l</code> looks up something, returning <code class="code">None</code> if not found.<br>
</div>
<pre><span id="VALlookup_failnull"><span class="keyword">val</span> lookup_failnull</span> : <code class="type">'a -> ('a * 'b) list -> 'b</code></pre><div class="info ">
Same as <code class="code">lookup</code>, but no option type. Raises <code class="code">Not_found</code> if the key is not there.<br>
</div>
<pre><span id="VALadd"><span class="keyword">val</span> add</span> : <code class="type">'a -> 'b -> ('a * 'b) list -> ('a * 'b) list</code></pre><div class="info ">
<code class="code">add k v l</code> Adds <code class="code">(k, v)</code> to a dictionary, replacing any existing binding of
<code class="code">k</code>.<br>
</div>
<pre><span id="VALreplace"><span class="keyword">val</span> replace</span> : <code class="type">'a -> 'b -> ('a * 'b) list -> ('a * 'b) list</code></pre><div class="info ">
<code class="code">replace k v l</code> replaces the existing binding of <code class="code">k</code> in <code class="code">l</code> with one with binds <code class="code">k</code>
to <code class="code">v</code>. Raises <code class="code">Not_found</code> if there is nothing to replace.<br>
</div>
<pre><span id="VALremove"><span class="keyword">val</span> remove</span> : <code class="type">'a -> ('a * 'b) list -> ('a * 'b) list</code></pre><div class="info ">
Remove something from a list, if it's there. If not, don't complain.<br>
</div>
<pre><span id="VALmergedict"><span class="keyword">val</span> mergedict</span> : <code class="type">('a * 'b) list -> ('a * 'b) list -> ('a * 'b) list</code></pre><div class="info ">
Merge two lists, preferring elements in the second in the case of clashes.<br>
</div>
<br>
<h2 id="2_References">References</h2><br>
<pre><span id="VALset"><span class="keyword">val</span> set</span> : <code class="type">bool Pervasives.ref -> unit</code></pre><div class="info ">
Set a boolean reference to <code class="code">true</code><br>
</div>
<pre><span id="VALclear"><span class="keyword">val</span> clear</span> : <code class="type">bool Pervasives.ref -> unit</code></pre><div class="info ">
Set a boolean reference to <code class="code">false</code><br>
</div>
<pre><span id="VALflip"><span class="keyword">val</span> flip</span> : <code class="type">bool Pervasives.ref -> unit</code></pre><div class="info ">
Flip a boolean reference<br>
</div>
<pre><span id="VAL(+=)"><span class="keyword">val</span> (+=)</span> : <code class="type">int Pervasives.ref -> int -> unit</code></pre>
<pre><span id="VAL(-=)"><span class="keyword">val</span> (-=)</span> : <code class="type">int Pervasives.ref -> int -> unit</code></pre>
<pre><span id="VAL(/=)"><span class="keyword">val</span> (/=)</span> : <code class="type">int Pervasives.ref -> int -> unit</code></pre>
<pre><span id="VAL( *= )"><span class="keyword">val</span> ( *= )</span> : <code class="type">int Pervasives.ref -> int -> unit</code></pre><div class="info ">
Operations on integer references<br>
</div>
<pre><span id="VAL(+.=)"><span class="keyword">val</span> (+.=)</span> : <code class="type">float Pervasives.ref -> float -> unit</code></pre>
<pre><span id="VAL(-.=)"><span class="keyword">val</span> (-.=)</span> : <code class="type">float Pervasives.ref -> float -> unit</code></pre>
<pre><span id="VAL(/.=)"><span class="keyword">val</span> (/.=)</span> : <code class="type">float Pervasives.ref -> float -> unit</code></pre>
<pre><span id="VAL( *.= )"><span class="keyword">val</span> ( *.= )</span> : <code class="type">float Pervasives.ref -> float -> unit</code></pre><div class="info ">
Operations on floating point references<br>
</div>
<pre><span id="VAL(=|)"><span class="keyword">val</span> (=|)</span> : <code class="type">'a list Pervasives.ref -> 'a -> unit</code></pre><div class="info ">
Cons something onto the contents of a list reference.<br>
</div>
<pre><span id="VAL(=@)"><span class="keyword">val</span> (=@)</span> : <code class="type">'a list Pervasives.ref -> 'a list -> unit</code></pre><div class="info ">
Append something to the front of the contents of a list reference.<br>
</div>
<br>
<h2 id="2_Geometry">Geometry</h2><br>
<pre><span id="TYPEvector"><span class="keyword">type</span> <code class="type"></code>vector</span> = <code class="type">float * float</code> </pre>
<div class="info ">
The type of vectors.<br>
</div>
<pre><span id="VALmkvector"><span class="keyword">val</span> mkvector</span> : <code class="type">float * float -> float * float -> <a href="Pdfutil.html#TYPEvector">vector</a></code></pre><div class="info ">
<code class="code">mkvector (a, b) (c, d)</code> makes a vector from point <code class="code">(a, b)</code> to point <code class="code">(c, d)</code>.<br>
</div>
<pre><span id="VALinvert"><span class="keyword">val</span> invert</span> : <code class="type"><a href="Pdfutil.html#TYPEvector">vector</a> -> <a href="Pdfutil.html#TYPEvector">vector</a></code></pre><div class="info ">
Invert a vector.<br>
</div>
<pre><span id="VALoffset_point"><span class="keyword">val</span> offset_point</span> : <code class="type"><a href="Pdfutil.html#TYPEvector">vector</a> -> float * float -> <a href="Pdfutil.html#TYPEvector">vector</a></code></pre><div class="info ">
Offset a point by a vector.<br>
</div>
<pre><span id="VALperpendicular"><span class="keyword">val</span> perpendicular</span> : <code class="type">'a * float -> float * 'a</code></pre><div class="info ">
Find the vector <code class="code">pi / 2</code> anticlockwise from the given one.<br>
</div>
<pre><span id="VALsqr"><span class="keyword">val</span> sqr</span> : <code class="type">float -> float</code></pre><div class="info ">
Square a number<br>
</div>
<pre><span id="VALveclength"><span class="keyword">val</span> veclength</span> : <code class="type"><a href="Pdfutil.html#TYPEvector">vector</a> -> float</code></pre><div class="info ">
The length of a vector.<br>
</div>
<pre><span id="VALscalevectolength"><span class="keyword">val</span> scalevectolength</span> : <code class="type">float -> <a href="Pdfutil.html#TYPEvector">vector</a> -> <a href="Pdfutil.html#TYPEvector">vector</a></code></pre><div class="info ">
Scale a vector to a given length.<br>
</div>
<pre><span id="VALmkunitvector"><span class="keyword">val</span> mkunitvector</span> : <code class="type">float * float -> float * float -> <a href="Pdfutil.html#TYPEvector">vector</a></code></pre><div class="info ">
Make a unit vector in the direction from one point to a second.<br>
</div>
<pre><span id="VALbetween"><span class="keyword">val</span> between</span> : <code class="type">float * float -> float * float -> float * float</code></pre><div class="info ">
Find the point equidistant between two others.<br>
</div>
<pre><span id="VALdistance_between"><span class="keyword">val</span> distance_between</span> : <code class="type">float * float -> float * float -> float</code></pre><div class="info ">
Cartesian distance between two points.<br>
</div>
<br>
<h2 id="2_Numbers">Numbers</h2><br>
<pre><span id="VALround"><span class="keyword">val</span> round</span> : <code class="type">float -> float</code></pre><div class="info ">
Round a real.<br>
</div>
<pre><span id="VALiround"><span class="keyword">val</span> iround</span> : <code class="type">float -> int</code></pre><div class="info ">
The same, returning an integer.<br>
</div>
<pre><span id="VALlargest_pow2_divisible"><span class="keyword">val</span> largest_pow2_divisible</span> : <code class="type">int -> int</code></pre><div class="info ">
The largest power of two by which a number is exactly divisible.<br>
</div>
<pre><span id="VALpow2lt"><span class="keyword">val</span> pow2lt</span> : <code class="type">int -> int</code></pre><div class="info ">
Largest power of two smaller or equal to an integer.<br>
</div>
<pre><span id="VALpow2gt"><span class="keyword">val</span> pow2gt</span> : <code class="type">int -> int</code></pre><div class="info ">
Largest power of two greater or equal to an integer.<br>
</div>
<pre><span id="VALlog2of"><span class="keyword">val</span> log2of</span> : <code class="type">int -> int</code></pre><div class="info ">
Base two logarithm<br>
</div>
<pre><span id="VALpow"><span class="keyword">val</span> pow</span> : <code class="type">int -> int -> int</code></pre><div class="info ">
<code class="code">pow x y</code> is y to the power x<br>
</div>
<pre><span id="VALcompare_i"><span class="keyword">val</span> compare_i</span> : <code class="type">int -> int -> int</code></pre><div class="info ">
Monomorphic integer version of <code class="code">Pervasives.compare</code><br>
</div>
<pre><span id="VALmin"><span class="keyword">val</span> min</span> : <code class="type">int -> int -> int</code></pre>
<pre><span id="VALmax"><span class="keyword">val</span> max</span> : <code class="type">int -> int -> int</code></pre><div class="info ">
Monomorphic integer versions of <code class="code">Pervasives</code> functions.<br>
</div>
<pre><span id="VALfmin"><span class="keyword">val</span> fmin</span> : <code class="type">float -> float -> float</code></pre>
<pre><span id="VALfmax"><span class="keyword">val</span> fmax</span> : <code class="type">float -> float -> float</code></pre>
<pre><span id="VALfabs"><span class="keyword">val</span> fabs</span> : <code class="type">float -> float</code></pre><div class="info ">
Monomorphic floating-point versions of <code class="code">Pervasives</code> functions<br>
</div>
<pre><span id="VALeven"><span class="keyword">val</span> even</span> : <code class="type">int -> bool</code></pre>
<pre><span id="VALodd"><span class="keyword">val</span> odd</span> : <code class="type">int -> bool</code></pre><div class="info ">
Even and odd predicates on integers. Work for negative numbers.<br>
</div>
<pre><span id="VALpi"><span class="keyword">val</span> pi</span> : <code class="type">float</code></pre><div class="info ">
Pi.<br>
</div>
<pre><span id="VALroot2"><span class="keyword">val</span> root2</span> : <code class="type">float</code></pre><div class="info ">
Square root of two.<br>
</div>
<pre><span id="VALrad_of_deg"><span class="keyword">val</span> rad_of_deg</span> : <code class="type">float -> float</code></pre>
<pre><span id="VALdeg_of_rad"><span class="keyword">val</span> deg_of_rad</span> : <code class="type">float -> float</code></pre><div class="info ">
Convert between radians and degrees.<br>
</div>
<pre><span id="VALsign_extend"><span class="keyword">val</span> sign_extend</span> : <code class="type">int -> int -> int</code></pre><div class="info ">
The call <code class="code">sign_extend l n</code> extends <code class="code">n</code> of length <code class="code">l</code> bits to fit a native integer<br>
</div>
<pre><span id="VALisdigit"><span class="keyword">val</span> isdigit</span> : <code class="type">char -> bool</code></pre><div class="info ">
A character is a decimal digit.<br>
</div>
<pre><span id="VALtoint"><span class="keyword">val</span> toint</span> : <code class="type">float -> int</code></pre><div class="info ">
Same as <code class="code">Pervasives.int_of_float</code><br>
</div>
<pre><span id="VALsafe_float"><span class="keyword">val</span> safe_float</span> : <code class="type">float -> float</code></pre><div class="info ">
Make sure a floating point number is no degenarate, by making it zero if it is.<br>
</div>
<br>
<h2 id="2_Options">Options</h2><br>
<pre><span id="VALsome"><span class="keyword">val</span> some</span> : <code class="type">'a option -> bool</code></pre>
<pre><span id="VALnone"><span class="keyword">val</span> none</span> : <code class="type">'a option -> bool</code></pre><div class="info ">
Predicates on the someness or noneness of an <code class="code">'a option</code>.<br>
</div>
<pre><span id="VALunopt"><span class="keyword">val</span> unopt</span> : <code class="type">'a option -> 'a</code></pre><div class="info ">
Strip the <code class="code">Some</code> from an option. Fail if it's <code class="code">None</code>.<br>
</div>
<br>
<h2 id="2_Hashtables">Hash tables</h2><br>
<pre><span id="VALnull_hash"><span class="keyword">val</span> null_hash</span> : <code class="type">unit -> ('a, 'b) Hashtbl.t</code></pre><div class="info ">
The empty zero-sized hash table.<br>
</div>
<pre><span id="VALtryfind"><span class="keyword">val</span> tryfind</span> : <code class="type">('a, 'b) Hashtbl.t -> 'a -> 'b option</code></pre><div class="info ">
Option lookup on hashtables<br>
</div>
<pre><span id="VALlist_of_hashtbl"><span class="keyword">val</span> list_of_hashtbl</span> : <code class="type">('a, 'b) Hashtbl.t -> ('a * 'b) list</code></pre><div class="info ">
Make a list of key-value pairs reflecting the contents of a hash table.<br>
</div>
<pre><span id="VALhashtable_of_dictionary"><span class="keyword">val</span> hashtable_of_dictionary</span> : <code class="type">('a * 'b) list -> ('a, 'b) Hashtbl.t</code></pre><div class="info ">
Build a hashtable from a dictionary (list of key-value pairs). Items are
added from left to right, with no checking for duplicate keys being performed.<br>
</div>
<br>
<h2 id="2_Trees">Trees</h2><br>
<pre><code><span id="TYPEtree"><span class="keyword">type</span> <code class="type">'a</code> tree</span> = </code></pre><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTtree.Lf"><span class="constructor">Lf</span></span></code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span id="TYPEELTtree.Br"><span class="constructor">Br</span></span> <span class="keyword">of</span> <code class="type">'a * 'a <a href="Pdfutil.html#TYPEtree">tree</a> * 'a <a href="Pdfutil.html#TYPEtree">tree</a></code></code></td>
</tr></table>
<div class="info ">
The type for binary trees.<br>
</div>
<br>
<h2 id="2_Arrays">Arrays</h2><br>
<pre><span id="VALarray_iter2"><span class="keyword">val</span> array_iter2</span> : <code class="type">('a -> 'b -> unit) -> 'a array -> 'b array -> unit</code></pre><div class="info ">
<code class="code">iter2</code> on arrays.<br>
</div>
<pre><span id="VALarray_map2"><span class="keyword">val</span> array_map2</span> : <code class="type">('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array</code></pre><div class="info ">
<code class="code">map2</code> on arrays.<br>
</div>
<pre><span id="VALswap"><span class="keyword">val</span> swap</span> : <code class="type">'a array -> int -> int -> unit</code></pre><div class="info ">
Swaps the data at the given indexes in an array.<br>
</div>
<pre><span id="VALset_array"><span class="keyword">val</span> set_array</span> : <code class="type">'a array -> 'a -> unit</code></pre><div class="info ">
Set all the values of an array.<br>
</div>
<br>
<h2 id="2_Controlflow">Control flow</h2><br>
<pre><span id="VALmemoize"><span class="keyword">val</span> memoize</span> : <code class="type">(unit -> 'a) -> unit -> 'a</code></pre><div class="info ">
<code class="code">memoize f</code> builds a memoized version of the function <code class="code">f</code>.<br>
</div>
<pre><span id="VALident"><span class="keyword">val</span> ident</span> : <code class="type">'a -> 'a</code></pre><div class="info ">
The identity function.<br>
</div>
<pre><span id="VALapplyn"><span class="keyword">val</span> applyn</span> : <code class="type">('a -> 'a) -> int -> 'a -> 'a</code></pre><div class="info ">
Apply a function <code class="code">f</code> <code class="code">n</code> times to initial argument <code class="code">arg</code>.<br>
</div>
<pre><span id="VAL(<|)"><span class="keyword">val</span> (<|)</span> : <code class="type">('a -> 'b) -> 'a -> 'b</code></pre><div class="info ">
This is equivalent to <code class="code">let ( <| ) a b = a b</code><br>
</div>
<pre><span id="VALmkunit"><span class="keyword">val</span> mkunit</span> : <code class="type">('a -> 'b) -> 'a -> unit -> 'b</code></pre><div class="info ">
<code class="code">mkunit f x</code> gives <code class="code">fun () -> f x</code><br>
</div>
<br>
<h2 id="2_Tuples">Tuples</h2><br>
<pre><span id="VALtuple"><span class="keyword">val</span> tuple</span> : <code class="type">'a -> 'b -> 'a * 'b</code></pre><div class="info ">
Make a tuple.<br>
</div>
<pre><span id="VALconspair"><span class="keyword">val</span> conspair</span> : <code class="type">('a * 'b) * ('a list * 'b list) -> 'a list * 'b list</code></pre><div class="info ">
Consing to each of a pair of lists at the same time.<br>
</div>
<pre><span id="VALconspairopt"><span class="keyword">val</span> conspairopt</span> : <code class="type">('a option * 'b option) * ('a list * 'b list) -> 'a list * 'b list</code></pre><div class="info ">
Version of <code class="code">conspair</code> where there may or may not be somthing to cons in each case.<br>
</div>
<pre><span id="VALpairs_of_list"><span class="keyword">val</span> pairs_of_list</span> : <code class="type">'a list -> ('a * 'a) list</code></pre><div class="info ">
Make consecutive elements of an even-length list into a list of pairs.<br>
</div>
<pre><span id="VALdo_return"><span class="keyword">val</span> do_return</span> : <code class="type">(unit -> 'a) -> (unit -> 'b) -> 'a</code></pre><div class="info ">
<code class="code">do_return f g</code> Evaluate <code class="code">f ()</code>, evaluate and ignore <code class="code">g ()</code>, return <code class="code">f ()</code>, in that order.<br>
</div>
<pre><span id="VALdo_many"><span class="keyword">val</span> do_many</span> : <code class="type">(unit -> unit) -> int -> unit</code></pre><div class="info ">
<code class="code">do_many f n</code> calls <code class="code">f ()</code> n times.<br>
</div>
<br>
<h2 id="2_Equality">Equality</h2><br>
<pre><span id="VALeq"><span class="keyword">val</span> eq</span> : <code class="type">'a -> 'a -> bool</code></pre><div class="info ">
Equality.<br>
</div>
<pre><span id="VALneq"><span class="keyword">val</span> neq</span> : <code class="type">'a -> 'a -> bool</code></pre><div class="info ">
Inequality.<br>
</div>
<pre><span id="VALrev_compare"><span class="keyword">val</span> rev_compare</span> : <code class="type">'a -> 'a -> int</code></pre><div class="info ">
Like <code class="code">Pervasives.compare</code>, but the other way around.<br>
</div>
<br>
<h2 id="2_Logic">Logic</h2><br>
<pre><span id="VALalways"><span class="keyword">val</span> always</span> : <code class="type">'a -> bool</code></pre><div class="info ">
The always-true predicate.<br>
</div>
<pre><span id="VALnever"><span class="keyword">val</span> never</span> : <code class="type">'a -> bool</code></pre><div class="info ">
The always-false predicate.<br>
</div>
<pre><span id="VAL(|&|)"><span class="keyword">val</span> (|&|)</span> : <code class="type">bool -> bool -> bool</code></pre><div class="info ">
Exclusive OR<br>
</div>
<pre><span id="VALnotpred"><span class="keyword">val</span> notpred</span> : <code class="type">('a -> bool) -> 'a -> bool</code></pre><div class="info ">
Invert a predicate.<br>
</div>
<br>
<h2 id="2_Boxes">Boxes</h2><br>
<pre><span id="VALbox_union"><span class="keyword">val</span> box_union</span> : <code class="type">int * int * int * int -> int * int * int * int -> int * int * int * int</code></pre><div class="info ">
The smallest box enclosing both given integer boxes. Each box is <code class="code">(xmin, xmax, ymin, ymax)</code>.<br>
</div>
<pre><span id="VALbox_union_float"><span class="keyword">val</span> box_union_float</span> : <code class="type">float * float * float * float -><br> float * float * float * float -> float * float * float * float</code></pre><div class="info ">
The smallest box enclosing both given floating-point boxes. Each box is <code class="code">(xmin, xmax, ymin, ymax)</code>.<br>
</div>
<pre><span id="VALbox_overlap"><span class="keyword">val</span> box_overlap</span> : <code class="type">int -><br> int -><br> int -> int -> int -> int -> int -> int -> (int * int * int * int) option</code></pre><div class="info ">
The intersection box (if any) of two integer boxes, each defined as <code class="code">xmin ymin xmax ymax</code>.<br>
</div>
<pre><span id="VALbox_overlap_float"><span class="keyword">val</span> box_overlap_float</span> : <code class="type">float -><br> float -><br> float -><br> float -><br> float -> float -> float -> float -> (float * float * float * float) option</code></pre><div class="info ">
The intersection box (if any) of two floating-point boxes, each defined as <code class="code">xmin ymin xmax ymax</code>.<br>
</div>
<br>
<h2 id="2_Filenames">Filenames</h2><br>
<pre><span id="VALslash"><span class="keyword">val</span> slash</span> : <code class="type">string</code></pre><div class="info ">
The correct separator for filenames on the current platform.<br>
</div>
<pre><span id="VALleafnames_of_dir"><span class="keyword">val</span> leafnames_of_dir</span> : <code class="type">string -> string list</code></pre><div class="info ">
Return a list of leafnames for the given folder in the current folder<br>
</div>
<br>
<h2 id="2_Romannumerals">Roman numerals</h2><br>
<pre><span id="VALroman_upper"><span class="keyword">val</span> roman_upper</span> : <code class="type">int -> string</code></pre><div class="info ">
Uppercase roman representation of a number<br>
</div>
<pre><span id="VALroman_lower"><span class="keyword">val</span> roman_lower</span> : <code class="type">int -> string</code></pre><div class="info ">
Lowercase roman representation of a number<br>
</div>
</body></html>
distrib
>
Mageia
>
5
>
x86_64
>
media
>
core-release
>
by-pkgid
>
a94aa4b565ade94d0310c6e77aeea765
>
files
>
87
