mirror of
https://github.com/c-cube/ocaml-containers.git
synced 2025-12-07 11:45:31 -05:00
7 lines
27 KiB
HTML
7 lines
27 KiB
HTML
<!DOCTYPE html>
|
||
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make_from_compare (containers.CCHeap.Make_from_compare)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 2.4.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">containers</a> » <a href="../index.html">CCHeap</a> » Make_from_compare</nav><header class="odoc-preamble"><h1>Module <code><span>CCHeap.Make_from_compare</span></code></h1><p>A convenient version of <code>Make</code> that takes a <code>TOTAL_ORD</code> instead of a partially ordered module. It allows to directly pass modules that implement <code>compare</code> without implementing <code>leq</code> explicitly.</p></header><nav class="odoc-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a><ul><li><a href="#basic-heap-operations">Basic heap operations</a></li><li><a href="#deleting-elements">Deleting elements</a></li><li><a href="#iterating-on-elements">Iterating on elements</a></li><li><a href="#adding-many-elements-at-once">Adding many elements at once</a></li><li><a href="#conversions">Conversions</a></li><li><a href="#pretty-printing">Pretty-printing</a></li></ul></li></ul></nav><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-E"><a href="#argument-1-E" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-E/index.html">E</a></span><span> : <a href="../module-type-TOTAL_ORD/index.html">TOTAL_ORD</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec type anchored" id="type-elt"><a href="#type-elt" class="anchor"></a><code><span><span class="keyword">type</span> elt</span><span> = <a href="argument-1-E/index.html#type-t">E.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Empty"><a href="#exception-Empty" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Empty</span></span></code></div></div><h3 id="basic-heap-operations"><a href="#basic-heap-operations" class="anchor"></a>Basic heap operations</h3><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>empty</code> returns the empty heap.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span><span class="keyword">val</span> is_empty : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> bool</span></code></div><div class="spec-doc"><p><code>is_empty h</code> returns <code>true</code> iff the heap <code>h</code> is empty.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-merge"><a href="#val-merge" class="anchor"></a><code><span><span class="keyword">val</span> merge : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>merge h1 h2</code> merges the two heaps <code>h1</code> and <code>h2</code>. If one heap is empty, the result is physically equal to the other heap. Complexity: <code>O(log (m+n))</code> where <code>m</code> and <code>n</code> are the number of elements in each heap.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-insert"><a href="#val-insert" class="anchor"></a><code><span><span class="keyword">val</span> insert : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>insert x h</code> inserts an element <code>x</code> into the heap <code>h</code>. Complexity: <code>O(log n)</code> where <code>n</code> is the number of elements in <code>h</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>add h x</code> is <code>insert x h</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_min"><a href="#val-find_min" class="anchor"></a><code><span><span class="keyword">val</span> find_min : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> option</span></span></code></div><div class="spec-doc"><p><code>find_min h</code> returns the minimal element of <code>h</code>, or <code>None</code> if <code>h</code> is empty. Complexity: <code>O(1)</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_min_exn"><a href="#val-find_min_exn" class="anchor"></a><code><span><span class="keyword">val</span> find_min_exn : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div><div class="spec-doc"><p><code>find_min_exn h</code> is akin to <a href="#val-find_min"><code>find_min</code></a>, but it raises <a href="#exception-Empty"><code>Empty</code></a> when the heap is empty.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <a href="#exception-Empty"><code>Empty</code></a> <p>if the heap is empty.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take"><a href="#val-take" class="anchor"></a><code><span><span class="keyword">val</span> take : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><span>(<a href="#type-t">t</a> * <a href="#type-elt">elt</a>)</span> option</span></span></code></div><div class="spec-doc"><p><code>take h</code> returns the minimum element of <code>h</code> and the new heap without this element, or <code>None</code> if <code>h</code> is empty. Complexity: <code>O(log n)</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take_exn"><a href="#val-take_exn" class="anchor"></a><code><span><span class="keyword">val</span> take_exn : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <a href="#type-t">t</a> * <a href="#type-elt">elt</a></span></code></div><div class="spec-doc"><p><code>take_exn h</code> is akin to <a href="#val-take"><code>take</code></a>, but it raises <a href="#exception-Empty"><code>Empty</code></a> when the heap is empty.</p><ul class="at-tags"><li class="raises"><span class="at-tag">raises</span> <a href="#exception-Empty"><code>Empty</code></a> <p>if the heap is empty.</p></li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-size"><a href="#val-size" class="anchor"></a><code><span><span class="keyword">val</span> size : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> int</span></code></div><div class="spec-doc"><p><code>size h</code> is the number of elements in the heap <code>h</code>. Complexity: <code>O(n)</code>.</p></div></div><h3 id="deleting-elements"><a href="#deleting-elements" class="anchor"></a>Deleting elements</h3><div class="odoc-spec"><div class="spec value anchored" id="val-delete_one"><a href="#val-delete_one" class="anchor"></a><code><span><span class="keyword">val</span> delete_one : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>delete_one eq x h</code> deletes an occurrence of the value <code>x</code> from the heap <code>h</code>, if there is some. If <code>h</code> does not contain <code>x</code>, then <code>h</code> itself is returned. Elements are identified by the equality function <code>eq</code>. Complexity: <code>O(n)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-delete_all"><a href="#val-delete_all" class="anchor"></a><code><span><span class="keyword">val</span> delete_all : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>delete_all eq x h</code> deletes all occurrences of the value <code>x</code> from the heap <code>h</code>. If <code>h</code> does not contain <code>x</code>, then <code>h</code> itself is returned. Elements are identified by the equality function <code>eq</code>. This function is more efficient than <a href="#val-filter"><code>filter</code></a> because it avoids considering elements greater than <code>x</code>. Complexity: <code>O(n)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span><span class="keyword">val</span> filter : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>filter p h</code> filters the elements of <code>h</code>, only retaining those that satisfy the predicate <code>p</code>. If no element in <code>h</code> satisfies <code>p</code>, then <code>h</code> itself is returned. Complexity: <code>O(n)</code>.</p></div></div><h3 id="iterating-on-elements"><a href="#iterating-on-elements" class="anchor"></a>Iterating on elements</h3><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-t">t</a> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p><code>iter f h</code> invokes <code>f</code> on every element of the heap <code>h</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span class="type-var">'a</span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>fold f acc h</code> folds on all elements of <code>h</code>.</p></div></div><h3 id="adding-many-elements-at-once"><a href="#adding-many-elements-at-once" class="anchor"></a>Adding many elements at once</h3><div class="odoc-spec"><div class="spec value anchored" id="val-add_list"><a href="#val-add_list" class="anchor"></a><code><span><span class="keyword">val</span> add_list : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><span><a href="#type-elt">elt</a> list</span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>add_list h l</code> adds the elements of the list <code>l</code> into the heap <code>h</code>. An element occurring several times will be added that many times to the heap. Elements need not be given in any particular order. This function is more efficient than repeated insertions. Complexity: <code>O(log m + n)</code> where <code>m</code> and <code>n</code> are the number of elements in <code>h</code> and <code>l</code>, respectively.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.16</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_iter"><a href="#val-add_iter" class="anchor"></a><code><span><span class="keyword">val</span> add_iter : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><span><a href="#type-elt">elt</a> <a href="../index.html#type-iter">iter</a></span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>add_iter h iter</code> is akin to <a href="#val-add_list"><code>add_list</code></a>, but taking an <a href="../index.html#type-iter"><code>iter</code></a> of elements as input.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span><span class="keyword">val</span> add_seq : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><span><a href="#type-elt">elt</a> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>add_seq h seq</code> is akin to <a href="#val-add_list"><code>add_list</code></a>, but taking a <code>Seq.t</code> of elements as input. Renamed from <code>add_std_seq</code> since 3.0.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_gen"><a href="#val-add_gen" class="anchor"></a><code><span><span class="keyword">val</span> add_gen : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><span><a href="#type-elt">elt</a> <a href="../index.html#type-gen">gen</a></span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>add_gen h gen</code> is akin to <a href="#val-add_list"><code>add_list</code></a>, but taking a <a href="../index.html#type-gen"><code>gen</code></a> of elements as input.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.16</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_iter_almost_sorted"><a href="#val-add_iter_almost_sorted" class="anchor"></a><code><span><span class="keyword">val</span> add_iter_almost_sorted : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><span><a href="#type-elt">elt</a> <a href="../index.html#type-iter">iter</a></span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>add_iter_almost_sorted h iter</code> is equivalent to <code>merge h (of_iter_almost_sorted iter)</code>. See <a href="#val-of_iter_almost_sorted"><code>of_iter_almost_sorted</code></a>. Complexity: <code>O(log m + n)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.14</li></ul></div></div><h3 id="conversions"><a href="#conversions" class="anchor"></a>Conversions</h3><div class="odoc-spec"><div class="spec value anchored" id="val-of_list"><a href="#val-of_list" class="anchor"></a><code><span><span class="keyword">val</span> of_list : <span><span><a href="#type-elt">elt</a> list</span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>of_list l</code> builds a heap from the list of elements <code>l</code>. Elements need not be given in any particular order. This function is more efficient than repeated insertions. It is equivalent to <a href="#val-add_list"><code>add_list</code></a><code> empty l</code>. Complexity: <code>O(n)</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_iter"><a href="#val-of_iter" class="anchor"></a><code><span><span class="keyword">val</span> of_iter : <span><span><a href="#type-elt">elt</a> <a href="../index.html#type-iter">iter</a></span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>of_iter iter</code> is akin to <a href="#val-of_list"><code>of_list</code></a>, but taking an <a href="../index.html#type-iter"><code>iter</code></a> of elements as input.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><a href="#type-elt">elt</a> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>of_seq seq</code> is akin to <a href="#val-of_list"><code>of_list</code></a>, but taking a <code>Seq.t</code> of elements as input. Renamed from <code>of_std_seq</code> since 3.0.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_gen"><a href="#val-of_gen" class="anchor"></a><code><span><span class="keyword">val</span> of_gen : <span><span><a href="#type-elt">elt</a> <a href="../index.html#type-gen">gen</a></span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>of_gen gen</code> is akin to <a href="#val-of_list"><code>of_list</code></a>, but taking a <a href="../index.html#type-gen"><code>gen</code></a> of elements as input.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_iter_almost_sorted"><a href="#val-of_iter_almost_sorted" class="anchor"></a><code><span><span class="keyword">val</span> of_iter_almost_sorted : <span><span><a href="#type-elt">elt</a> <a href="../index.html#type-iter">iter</a></span> <span class="arrow">-></span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>of_iter iter</code> builds a heap from the <a href="../index.html#type-iter"><code>iter</code></a> sequence of elements. Elements need not be given in any particular order. However, the heap takes advantage of partial sorting found in the input: the closer the input sequence is to being sorted, the more efficient it is to convert the heap to a sorted sequence. This enables heap-sorting that is faster than <code>O(n log n)</code> when the input is almost sorted. In the best case, when only a constant number of elements are misplaced, then successive <a href="#val-take"><code>take</code></a> run in <code>O(1)</code>, and <a href="#val-to_list_sorted"><code>to_list_sorted</code></a> runs in <code>O(n)</code>. Complexity: <code>O(n)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.14</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span><span class="keyword">val</span> to_list : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> list</span></span></code></div><div class="spec-doc"><p><code>to_list h</code> returns a list of the elements of the heap <code>h</code>, in no particular order. Complexity: <code>O(n)</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_iter"><a href="#val-to_iter" class="anchor"></a><code><span><span class="keyword">val</span> to_iter : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <a href="../index.html#type-iter">iter</a></span></span></code></div><div class="spec-doc"><p><code>to_iter h</code> is akin to <a href="#val-to_list"><code>to_list</code></a>, but returning an <a href="../index.html#type-iter"><code>iter</code></a> of elements.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div><div class="spec-doc"><p><code>to_seq h</code> is akin to <a href="#val-to_list"><code>to_list</code></a>, but returning a <code>Seq.t</code> of elements. Renamed from <code>to_std_seq</code> since 3.0.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_gen"><a href="#val-to_gen" class="anchor"></a><code><span><span class="keyword">val</span> to_gen : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <a href="../index.html#type-gen">gen</a></span></span></code></div><div class="spec-doc"><p><code>to_gen h</code> is akin to <a href="#val-to_list"><code>to_list</code></a>, but returning a <a href="../index.html#type-gen"><code>gen</code></a> of elements.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list_sorted"><a href="#val-to_list_sorted" class="anchor"></a><code><span><span class="keyword">val</span> to_list_sorted : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> list</span></span></code></div><div class="spec-doc"><p><code>to_list_sorted h</code> returns the list of elements of the heap <code>h</code> in increasing order. Complexity: <code>O(n log n)</code>.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 1.1</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_iter_sorted"><a href="#val-to_iter_sorted" class="anchor"></a><code><span><span class="keyword">val</span> to_iter_sorted : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <a href="../index.html#type-iter">iter</a></span></span></code></div><div class="spec-doc"><p><code>to_iter_sorted h</code> is akin to <a href="#val-to_list_sorted"><code>to_list_sorted</code></a>, but returning an <a href="../index.html#type-iter"><code>iter</code></a> of elements.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.8</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_sorted"><a href="#val-to_seq_sorted" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_sorted : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div><div class="spec-doc"><p><code>to_seq_sorted h</code> is akin to <a href="#val-to_list_sorted"><code>to_list_sorted</code></a>, but returning a <code>Seq.t</code> of elements. Renamed from <code>to_std_seq_sorted</code> since 3.0.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 3.0</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_tree"><a href="#val-to_tree" class="anchor"></a><code><span><span class="keyword">val</span> to_tree : <span><a href="#type-t">t</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <a href="../index.html#type-ktree">ktree</a></span></span></code></div><div class="spec-doc"><p><code>to_tree h</code> returns a <a href="../index.html#type-ktree"><code>ktree</code></a> of the elements of the heap <code>h</code>. The layout is not specified. Complexity: <code>O(n)</code>.</p></div></div><h3 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty-printing</h3><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><span class="optlabel">?sep</span>:string <span class="arrow">-></span></span> <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> string)</span> <span class="arrow">-></span></span> <span><a href="#type-t">t</a> <span class="arrow">-></span></span> string</span></code></div><div class="spec-doc"><p><code>to_string ?sep f h</code> prints the heap <code>h</code> to a string, using <code>f</code> to convert elements to strings and <code>sep</code> (default: <code>","</code>) as a separator between elements.</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 2.7</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp :
|
||
<span><span class="optlabel">?pp_start</span>:<span>unit <a href="../index.html#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span class="optlabel">?pp_stop</span>:<span>unit <a href="../index.html#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span class="optlabel">?pp_sep</span>:<span>unit <a href="../index.html#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><span><a href="#type-elt">elt</a> <a href="../index.html#type-printer">printer</a></span> <span class="arrow">-></span></span>
|
||
<span><a href="#type-t">t</a> <a href="../index.html#type-printer">printer</a></span></span></code></div><div class="spec-doc"><p><code>pp ?pp_start ?pp_stop ?pp_sep ppf h</code> prints <code>h</code> on <code>ppf</code>. Each element is formatted with <code>ppf</code>, <code>pp_start</code> is called at the beginning, <code>pp_stop</code> is called at the end, <code>pp_sep</code> is called between each element. By default, <code>pp_start</code> and <code>pp_stop</code> do nothing, and <code>pp_sep</code> is <code>(fun out -> Format.fprintf out ",@ ")</code>. Renamed from <code>print</code> since 2.0</p><ul class="at-tags"><li class="since"><span class="at-tag">since</span> 0.16</li></ul></div></div></div></body></html>
|