Commits

ariovistus  committed 8d79fd4

hello candydoc-enabled multi_index!

  • Participants
  • Parent commits 216c059

Comments (0)

Files changed (16)

File candydoc/candy.ddoc

+DDOC =  
+<html><head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8">
+<meta content="text/javascript" http-equiv="content-script-type">
+<title>$(TITLE)</title>
+<link rel="stylesheet" type="text/css" href="/candydoc/style.css">
+<!--[if lt IE 7]><link rel="stylesheet" type="text/css" href="/candydoc/ie56hack.css"><![endif]-->
+<script language="JavaScript" src="/candydoc/util.js" type="text/javascript"></script>
+<script language="JavaScript" src="/candydoc/tree.js" type="text/javascript"></script>
+<script language="JavaScript" src="/candydoc/explorer.js" type="text/javascript"></script>
+</head><body>
+<div id="tabarea"></div><div id="explorerclient"></div>
+<div id="content"><script>explorer.initialize("$(TITLE)");</script>
+	<table class="content">
+		<tr><td id="docbody"><h1>$(TITLE)</h1>$(BODY)</td></tr>
+		<tr><td id="docfooter">
+			Page was generated with
+			<img src="/candydoc/img/candydoc.gif" style="vertical-align:middle; position:relative; top:-1px">
+			on $(DATETIME)
+		</td></tr>
+	</table>
+</div>
+$(ADD_MODULES)
+</body></html>
+
+
+DDOC_DECL =
+<script>explorer.outline.writeEnabled = true;</script>
+$(DT <span class="decl">$0</span>)
+<script>explorer.outline.writeEnabled = false;</script>
+
+
+DDOC_PSYMBOL =
+<span class="currsymbol">$0</span>
+<script>explorer.outline.addDecl('$0');</script>
+
+
+DDOC_MEMBERS =
+<script>explorer.outline.incSymbolLevel();</script>
+$(DL $0)
+<script>explorer.outline.decSymbolLevel();</script>
+
+
+DDOC_PARAM_ID =
+<td nowrap valign="top" style="padding-right: 8px">$0</td>
+
+               
+DDOC_PARAM =<span class="funcparam">$0</span>
+ADD_MODULES =<script>$(MODULES)</script>
+MODULE =explorer.packageExplorer.addModule("$0");

File candydoc/pyd_candy.ddoc

-DDOC =  
-<html><head>
-<meta http-equiv="content-type" content="text/html; charset=utf-8">
-<meta content="text/javascript" http-equiv="content-script-type">
-<title>$(TITLE)</title>
-<link rel="stylesheet" type="text/css" href="/candydoc/style.css">
-<!--[if lt IE 7]><link rel="stylesheet" type="text/css" href="/candydoc/ie56hack.css"><![endif]-->
-<script language="JavaScript" src="/candydoc/util.js" type="text/javascript"></script>
-<script language="JavaScript" src="/candydoc/tree.js" type="text/javascript"></script>
-<script language="JavaScript" src="/candydoc/explorer.js" type="text/javascript"></script>
-</head><body>
-<div id="tabarea"></div><div id="explorerclient"></div>
-<div id="content"><script>explorer.initialize("$(TITLE)");</script>
-	<table class="content">
-		<tr><td id="docbody"><h1>$(TITLE)</h1>$(BODY)</td></tr>
-		<tr><td id="docfooter">
-			Page was generated with
-			<img src="/candydoc/img/candydoc.gif" style="vertical-align:middle; position:relative; top:-1px">
-			on $(DATETIME)
-		</td></tr>
-	</table>
-</div>
-$(ADD_MODULES)
-</body></html>
-
-
-DDOC_DECL =
-<script>explorer.outline.writeEnabled = true;</script>
-$(DT <span class="decl">$0</span>)
-<script>explorer.outline.writeEnabled = false;</script>
-
-
-DDOC_PSYMBOL =
-<span class="currsymbol">$0</span>
-<script>explorer.outline.addDecl('$0');</script>
-
-
-DDOC_MEMBERS =
-<script>explorer.outline.incSymbolLevel();</script>
-$(DL $0)
-<script>explorer.outline.decSymbolLevel();</script>
-
-
-DDOC_PARAM_ID =
-<td nowrap valign="top" style="padding-right: 8px">$0</td>
-
-               
-DDOC_PARAM =<span class="funcparam">$0</span>
-ADD_MODULES =<script>$(MODULES)</script>
-MODULE =explorer.packageExplorer.addModule("$0");
+CANDY = candydoc/candy.ddoc
+PYD = ../pyd/infrastructure/
+PYD_MODULES = ../pyd/doc/candydoc/modules.ddoc
+PYD_FILES = $(shell find $(PYD)/util $(PYD)/pyd $(PYD)/meta -name \*.d) $(PYD)/python/python.d 
+PYTHON_2_7 = -version=Python_2_7_Or_Later \
+             -version=Python_2_6_Or_Later \
+	     -version=Python_2_5_Or_Later \
+	     -version=Python_2_4_Or_Later 
+
+MI_MODULES = ../multi_index/doc/candydoc/modules.ddoc
+MI_SRC = ../multi_index/src/
+MI_FILES = $(MI_SRC)/ddoc.d $(MI_SRC)/replace.d
+all: _pyd_ _multi_index_
+
+_pyd_: $(PYD_FILES)
+	dmd -o- $(CANDY) $(PYD_MODULES) -Ddpyd $(PYD_FILES) $(PYTHON_2_7)
+_multi_index_:
+	dmd -o- $(CANDY) $(MI_MODULES) -Dd. $(MI_FILES) 
+	mv ddoc.html multi_index.html
+
+clean:
+	rm -f pyd/*.o
+	rm -f pyd/*.html
+	rm -f multi_index.html
+	rm -f replace.html

File multi_index.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-   "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-
-<!--
-	Copyright (c) 1999-2010 by Digital Mars
-	All Rights Reserved Written by Walter Bright
-	http://www.digitalmars.com
-  -->
-
-<head>
-<meta http-equiv="content-type" content="text/html; charset=utf-8" >
-<title>multi_index - D Programming Language - Digital Mars</title>
-<link rel="stylesheet" type="text/css" href="../style.css">
-
-<script>
-function listanchors()
-{
-    var a = document.getElementById("quickindex");
-    if (!a) return;
-    var newText = "";
-    var hash = new Array;
-    var n = 0;
-    var values = new Array;
-    // List all anchors.
-    for (var i = 0; i < document.anchors.length; i++)
-    {
-        var a = document.anchors[i];
-        var text = a.name;
-        if (hash[text] > 0) continue;
-        hash[text] = 1;
-    values[n++] = a.name
-    }
-
-    values.sort();
-
-    for(var i = 0; i < values.length; i++) {
-        var a = values[i];
-        newText += '<a href="#' + a + '"><span class="d_psymbol">'
-                + a + '</span></a> ';
-    }
-    if (newText != "") newText = "<p><b>Jump to:</b> " + newText + '</p>';
-    var a = document.getElementById("quickindex");
-    a.innerHTML = newText;
-}
-</script>
-
-</head>
-
-<body onload="listanchors()">
-<div id="heading">
-<!--
-	<a href="http://www.digitalmars.com/"><img src="../dmlogo.gif" width="270" height="53" border="0" alt="www.digitalmars.com" align="left"></a>
-	<p align="right">D Programming Language 2.0</p>
-
-
-	<div id="headingNav">
-	<ul>	<li><a href="http://www.prowiki.org/wiki4d/wiki.cgi?DocComments/" title="Read/write comments and feedback">Comments</a></li>
-	<li><a href="../index.html" title="D Programming Language" class="dlink">D</a></li>
-	<li><a href="http://www.digitalmars.com/advancedsearch.html" title="Search Digital Mars web site">Search</a></li>
-	<li><a href="http://www.digitalmars.com/" title="www.digitalmars.com">Home</a></li>
-	</ul>
-	</div>
-
-	<div id="lastupdate">Last update Sun Jul 22 17:53:21 2012
-</div>
-</div>
--->
-
-<div id="navigation">
-    <!--
-<div class="navblock">
-<form method="get" action="http://www.google.com/search">
-<div id="searchbox">
-<input id="q" name="q" size="10" value="RTL Search" onFocus='if(this.value == "RTL Search"){this.value="";}'>
-<input type="hidden" id="domains" name="domains" value="www.digitalmars.com">
-<input type="hidden" id="sitesearch" name="sitesearch" value="www.digitalmars.com/d/2.0/phobos">
-<input type="hidden" id="sourceid" name="sourceid" value="google-search">
-<input type="submit" id="submit" name="submit" value="Go">
-</div>
-</form>
-<div id="toctop">
-    <ul>	<li><a href="../index.html" title="D Programming Language">D</a></li>
-	<li><a href="../lex.html" title="D Language Specification">Language</a></li>
-	<li><a href="phobos.html" title="D Runtime Library">Phobos</a></li>
-	<li><a href="../comparison.html" title="Language Comparisons">Comparisons</a></li>
-    </ul>
-</div>
-</div>
- -->
-    <!-- 
-<div class="navblock">
-    <ul>	<li><a href="object.html" title="root of object hierarchy">object</a></li>
-    </ul>
-    <h2><a href="phobos.html#std" title="D standard modules">std</a></h2>
-    <ul>	<li><a href="std_algorithm.html" title="General-purpose algorithms">std.algorithm</a></li>
-	<li><a href="std_array.html" title="Array functions">std.array</a></li>
-	<li><a href="std_base64.html" title="Encode/decode base64 format">std.base64</a></li>
-	<li><a href="std_bigint.html" title="Arbitrary-precision ('bignum') arithmetic">std.bigint</a></li>
-	<li><a href="std_bind.html" title="Function argument binding">std.bind</a></li>
-	<li><a href="std_bitmanip.html" title="Bit-level manipulation">std.bitmanip</a></li>
-	<li><a href="std_boxer.html" title="Box/unbox types">std.boxer</a></li>
-	<li><a href="std_compiler.html" title="Information about the D compiler implementation">std.compiler</a></li>
-	<li><a href="std_complex.html" title="Complex numbers">std.complex</a></li>
-	<li><a href="std_concurrency.html" title="Message Passing">std.concurrency</a></li>
-	<li><a href="std_container.html" title="Containers">std.container</a></li>
-	<li><a href="std_contracts.html" title="Think assert">std.contracts</a></li>
-	<li><a href="std_conv.html" title="Conversion of strings to integers">std.conv</a></li>
-	<li><a href="std_cover.html" title="D coverage analyzer">std.cover</a></li>
-	<li><a href="std_cpuid.html" title="CPU identification">std.cpuid</a></li>
-	<li><a href="std_ctype.html" title="Simple character classification">std.ctype</a></li>
-	<li><a href="std_date.html" title="Date and time functions">std.date</a></li>
-	<li><a href="std_datetime.html" title="Date and time-related types and functions">std.datetime</a></li>
-	<li><a href="std_demangle.html" title="Demangle D names">std.demangle</a></li>
-	<li><a href="std_encoding.html" title="Character and string encoding">std.encoding</a></li>
-	<li><a href="std_exception.html" title="Exceptions and error handling">std.exception</a></li>
-	<li><a href="std_file.html" title="Basic file operations">std.file</a></li>
-	<li><a href="std_format.html" title="Formatted conversions of values to strings">std.format</a></li>
-	<li><a href="std_functional.html" title="functional">std.functional</a></li>
-	<li><a href="std_gc.html" title="Control the garbage collector">std.gc</a></li>
-	<li><a href="std_getopt.html" title="Command line options">std.getopt</a></li>
-	<li><a href="std_gregorian.html" title="Gregorian Calendar">std.gregorian</a></li>
-	<li><a href="std_intrinsic.html" title="Compiler built in intrinsic functions">std.intrinsic</a></li>
-	<li><a href="std_json.html" title="JSON reader">std.json</a></li>
-	<li><a href="std_math.html" title="the usual math functions">std.math</a></li>
-	<li><a href="std_mathspecial.html" title="mathematical special functions">std.mathspecial</a></li>
-	<li><a href="std_md5.html" title="Compute MD5 digests">std.md5</a></li>
-	<li><a href="std_metastrings.html" title="Metaprogramming with strings">std.metastrings</a></li>
-	<li><a href="std_mmfile.html" title="Memory mapped files">std.mmfile</a></li>
-	<li><a href="std_numeric.html" title="Numeric algorithms">std.numeric</a></li>
-	<li><a href="std_outbuffer.html" title="Assemble data into an array of bytes">std.outbuffer</a></li>
-	<li><a href="std_outofmemory.html" title="Out of memory exception">std.outofmemory</a></li>
-	<li><a href="std_path.html" title="Manipulate file names, path names, etc.">std.path</a></li>
-	<li><a href="std_parallelism.html" title="High level primitives for SMP parallelism">std.parallelism</a></li>
-	<li><a href="std_process.html" title="Create/destroy threads">std.process</a></li>
-	<li><a href="std_random.html" title="Random number generation">std.random</a></li>
-	<li><a href="std_range.html" title="Ranges">std.range</a></li>
-	<li><a href="std_regex.html" title="regular expressions">std.regex</a></li>
-	<li><a href="std_regexp.html" title="regular expressions (deprecated)">std.regexp</a></li>
-	<li><a href="std_signals.html" title="Signals">std.signals</a></li>
-	<li><a href="std_socket.html" title="Sockets">std.socket</a></li>
-	<li><a href="std_socketstream.html" title="Stream for a blocking, connected Socket">std.socketstream</a></li>
-	<li><a href="std_stdint.html" title="Integral types for various purposes">std.stdint</a></li>
-	<li><a href="std_stdio.html" title="Standard I/O">std.stdio</a></li>
-	<li><a href="std_cstream.html" title="Stream I/O">std.cstream</a></li>
-	<li><a href="std_stream.html" title="Stream I/O">std.stream</a></li>
-	<li><a href="std_string.html" title="Basic string operations">std.string</a></li>
-	<li><a href="std_system.html" title="Inquire about the CPU, operating system">std.system</a></li>
-	<li><a href="std_thread.html" title="Thread operations">std.thread</a></li>
-	<li><a href="std_traits.html" title="Type traits">std.traits</a></li>
-	<li><a href="std_typecons.html" title="Type constructors">std.typecons</a></li>
-	<li><a href="std_typetuple.html" title="Type tuples">std.typetuple</a></li>
-	<li><a href="std_uni.html" title="Unicode classification">std.uni</a></li>
-	<li><a href="std_uri.html" title="Encode and decode Uniform Resource Identifiers (URIs)">std.uri</a></li>
-	<li><a href="std_utf.html" title="Encode and decode utf character encodings">std.utf</a></li>
-	<li><a href="std_variant.html" title="Stores all types in a uniform, dynamically-checked representation">std.variant</a></li>
-	<li><a href="std_xml.html" title="XML file processing">std.xml</a></li>
-	<li><a href="std_zip.html" title="Read/write zip archives">std.zip</a></li>
-	<li><a href="std_zlib.html" title="Compression / Decompression of data">std.zlib</a></li>
-	<li><a href="std_c_fenv.html" title="Floating point environment">std.c.fenv</a></li>
-	<li><a href="std_c_locale.html" title="Locale">std.c.locale</a></li>
-	<li><a href="std_c_math.html" title="Math">std.c.math</a></li>
-	<li><a href="std_c_process.html" title="Process">std.c.process</a></li>
-	<li><a href="std_c_stdarg.html" title="Variadic arguments">std.c.stdarg</a></li>
-	<li><a href="std_c_stddef.html" title="Standard definitions">std.c.stddef</a></li>
-	<li><a href="std_c_stdio.html" title="Standard I/O">std.c.stdio</a></li>
-	<li><a href="std_c_stdlib.html" title="Standard library">std.c.stdlib</a></li>
-	<li><a href="std_c_string.html" title="Strings">std.c.string</a></li>
-	<li><a href="std_c_time.html" title="Time">std.c.time</a></li>
-	<li><a href="std_c_wcharh.html" title="Wide characters">std.c.wcharh</a></li>
-	<li><a href="std_net_isemail.html" title="Validate email addresses">std.net.isemail</a></li>
-	<li><a href="std_windows_charset.html" title="Conversion to/from Windows character sets">std.windows.charset</a></li>
-	<li><a href="phobos.html#std_windows" title="Modules specific to Windows">std.windows</a></li>
-	<li><a href="phobos.html#std_linux" title="Modules specific to Windows">std.linux</a></li>
-	<li><a href="phobos.html#std_c_windows" title="C Windows API">std.c.windows</a></li>
-	<li><a href="phobos.html#std_c_linux" title="C Linux API">std.c.linux</a></li>
-    </ul>
-    <h2><a href="phobos.html#core" title="D core modules">core</a></h2>
-    <ul>	<li><a href="core_atomic.html" title="Atomic operations">core.atomic</a></li>
-	<li><a href="core_bitop.html" title="Bitwise operations">core.bitop</a></li>
-	<li><a href="core_cpuid.html" title="CPU identification">core.cpuid</a></li>
-	<li><a href="core_exception.html" title="Root of exception hierarchy">core.exception</a></li>
-	<li><a href="core_memory.html" title="Interface to memory management">core.memory</a></li>
-	<li><a href="core_runtime.html" title="Interface to D runtime library internals">core.runtime</a></li>
-	<li><a href="core_time.html" title="Time">core.time</a></li>
-	<li><a href="core_thread.html" title="Thread management">core.thread</a></li>
-	<li><a href="core_vararg.html" title="Variable function arguments">core.vararg</a></li>
-	<li><a href="core_sync_barrier.html" title="Synchronizing progress of a group of threads">core.sync.barrier</a></li>
-	<li><a href="core_sync_condition.html" title="Synchronized condition checking">core.sync.condition</a></li>
-	<li><a href="core_sync_config.html" title="Stuff for core.sync">core.sync.config</a></li>
-	<li><a href="core_sync_exception.html" title="SyncException">core.sync.exception</a></li>
-	<li><a href="core_sync_mutex.html" title="Mutexes">core.sync.mutex</a></li>
-	<li><a href="core_sync_rwmutex.html" title="R/W mutually exclusive access">core.sync.rwmutex</a></li>
-	<li><a href="core_sync_semaphore.html" title="Semaphores">core.sync.semaphore</a></li>
-    </ul>
-</div>
- -->
-</div>
-<div id="content">
-    <h1>multi_index</h1>
-    <div id=quickindex class=quickindex></div>
-    <!-- Generated by Ddoc from src/ddoc.d -->
+
+<html><head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8">
+<meta content="text/javascript" http-equiv="content-script-type">
+<title>multi_index</title>
+<link rel="stylesheet" type="text/css" href="/candydoc/style.css">
+<!--[if lt IE 7]><link rel="stylesheet" type="text/css" href="/candydoc/ie56hack.css"><![endif]-->
+<script language="JavaScript" src="/candydoc/util.js" type="text/javascript"></script>
+<script language="JavaScript" src="/candydoc/tree.js" type="text/javascript"></script>
+<script language="JavaScript" src="/candydoc/explorer.js" type="text/javascript"></script>
+</head><body>
+<div id="tabarea"></div><div id="explorerclient"></div>
+<div id="content"><script>explorer.initialize("multi_index");</script>
+	<table class="content">
+		<tr><td id="docbody"><h1>multi_index</h1><!-- Generated by Ddoc from ../multi_index/src//ddoc.d -->
 A port of Joaquín M López Muñoz'
 <a
-href="http://www.boost.org/doc/libs/1_48_0/libs/multi_index/doc/index.html">
+href="http://www.boost.org/doc/libs/1_50_0/libs/multi_index/doc/index.html"
+>
 multi_index </a>
 library.
-<p></p>
+<br><br>
 compilation options: <br>
 <b>version=PtrHackery</b> - In boost::multi_index, Muñoz stores the color of a RB
 Tree Node in the low bit of one of the pointers with the rationale that on
 'many' architectures, pointers only point to even addresses.
 
-<p></p>
+<br><br>
 <b>Source:</b><br>
 <a href="https://bitbucket.org/ariovistus/multi_index/src/">https://bitbucket.org/ariovistus/multi_index/src/</a>
-<p></p>
-<b>License:</b><br>Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE_1_0.txt or copy at <a href="http://boost.org/LICENSE_1_0.txt">boost.org/LICENSE_1_0.txt</a>).
-
-<p></p>
-<b>Authors:</b><br>Steven Schveighoffer, Ellery Newcomer
-
-<p></p>
+<br><br>
+<b>License:</b><br>
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at ).
+
+<br><br>
+<b>Authors:</b><br>
+Steven Schveighoffer, Ellery Newcomer
+
+<br><br>
 <b>Introduction:</b><br>
 A standard container maintains its elements in a specific structure which
 allows it to offer interesting or useful access to its elements. However,
 primary container.
 In either solution, keeping the parallel containers synchronized quickly
 becomes a pain, and may introduce inefficiencies in time or memory complexity.
-<p></p>
-
-
-Into this use case steps <a name="multi_index"></a><u>multi_index</u>. It allows the user to specify multiple
+<br><br>
+
+Into this use case steps 
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script>. It allows the user to specify multiple
 <i>indeces</i> on the container elements, each of which provides interesting
-access functionality. A <a name="multi_index"></a><u>multi_index</u> container will automatically keep all
+access functionality. A 
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script> container will automatically keep all
 indeces synchronized over insertion, removal, or replacement operations
 performed on any one index.
-<p></p>
-
-
-Each index will typically require (<span class="d_inlinecode">N * ptrsize * k</span>) additional bytes of
+<br><br>
+
+Each index will typically require () additional bytes of
 memory, for some k &lt; 4
-<p></p>
-
+<br><br>
 
 <b>Quick Start</b>:
-<p></p>
-
-
-A MultiIndexContainer needs two things: a value type and a list of indeces. Put the list of indeces inside <span class="d_inlinecode">IndexedBy</span>.
-<p></p>
-
-
-<pre class="d_code"><span class="d_keyword">alias</span> MultiIndexContainer!(<span class="d_keyword">int</span>, IndexedBy!(Sequenced!())) MyContainer;
-
-MyContainer c = <span class="d_keyword">new</span> MyContainer;
+<br><br>
+
+A MultiIndexContainer needs two things: a value type and a list of indeces. Put the list of indeces inside .
+<br><br>
+
+<pre class="d_code"><font color=blue>alias</font> MultiIndexContainer!(<font color=blue>int</font>, IndexedBy!(Sequenced!())) MyContainer;
+
+MyContainer c = <font color=blue>new</font> MyContainer;
 </pre>
 
 If you like, you can name your indeces
-<pre class="d_code"><span class="d_keyword">alias</span> MultiIndexContainer!(<span class="d_keyword">int</span>, IndexedBy!(Sequenced!(),<span class="d_string">"seq"</span>)) MyContainer;
-
-MyContainer c = <span class="d_keyword">new</span> MyContainer;
+<pre class="d_code"><font color=blue>alias</font> MultiIndexContainer!(<font color=blue>int</font>, IndexedBy!(Sequenced!(),<font color=red>"seq"</font>)) MyContainer;
+
+MyContainer c = <font color=blue>new</font> MyContainer;
 </pre>
 
 Generally you do not perform operations on a MultiIndexContainer, but on one of
 its indeces. Access an index by its position in IndexedBy:
-<pre class="d_code"><span class="d_keyword">auto</span> seq_index = c.get_index!0;
+<pre class="d_code"><font color=blue>auto</font> seq_index = c.get_index!0;
 </pre>
 If you named your index, you can access it that way:
-<pre class="d_code"><span class="d_keyword">auto</span> seq_index = c.seq;
+<pre class="d_code"><font color=blue>auto</font> seq_index = c.seq;
 </pre>
 Although an element is inserted into the container through a single index,
 it must appear in every index, and each index provides a <i>default insertion</i>, which will be automatically invoked. This is relevant when an index
 provides multiple insertion methods:
-<pre class="d_code"><span class="d_keyword">alias</span> MultiIndexContainer!(<span class="d_keyword">int</span>, IndexedBy!(
-            Sequenced!(), <span class="d_string">"a"</span>,
-            Sequenced!(), <span class="d_string">"b"</span>)) DualList;
-
-DualList list = <span class="d_keyword">new</span> DualList();
-
-<span class="d_comment">// Sequenced defaults to insert to back
-</span>list.a.insert([1,2,3,4]);
-<span class="d_keyword">assert</span>(equals(list.a[], [1,2,3,4]));
-<span class="d_keyword">assert</span>(equals(list.b[], [1,2,3,4]));
+<pre class="d_code"><font color=blue>alias</font> MultiIndexContainer!(<font color=blue>int</font>, IndexedBy!(
+            Sequenced!(), <font color=red>"a"</font>,
+            Sequenced!(), <font color=red>"b"</font>)) DualList;
+
+DualList list = <font color=blue>new</font> DualList();
+
+<font color=green>// Sequenced defaults to insert to back
+</font>list.a.insert([1,2,3,4]);
+<font color=blue>assert</font>(equals(list.a[], [1,2,3,4]));
+<font color=blue>assert</font>(equals(list.b[], [1,2,3,4]));
 
 list.a.insertFront(5);
-<span class="d_keyword">assert</span>(equals(list.a[], [5,1,2,3,4]));
-<span class="d_keyword">assert</span>(equals(list.b[], [1,2,3,4,5]));
+<font color=blue>assert</font>(equals(list.a[], [5,1,2,3,4]));
+<font color=blue>assert</font>(equals(list.b[], [1,2,3,4,5]));
 </pre>
 
 The following index types are provided:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><p></p>
-
-
-<tr><th><span class="d_inlinecode">Sequenced</span></th></tr>
-<p></p>
-
-
-<tr><td valign=top>Provides a doubly linked list view - exposes
-fast access to the front and back of the index.  Default insertion inserts to
-the back of the index <br>
-<p></p>
-
-
-Complexities:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><th></th> <th></th></tr>
-<tr><td valign=top>Insertion</td> <td valign=top>i(n) = 1 for front and back insertion
-</td></tr>
-<tr><td valign=top>Removal</td> <td valign=top>d(n) = 1 for front, back, and auxiliary removal
-</td></tr>
-<tr><td valign=top>Replacement</td> <td valign=top>r(n) = 1 for auxiliary replacement
-</td></tr></table>
-<p></p>
-
-
-Supported Operations:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><td valign=top><span class="d_inlinecode">c[]
-</span></td><td valign=top>Returns a bidirectional range iterating over the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.front
-</span></td><td valign=top>Returns the first element inserted into the index
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.front = value
-</span></td><td valign=top>Replaces the front element in the index with value
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.back
-</span></td><td valign=top>Returns the last element inserted into the index
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.back = value
-</span></td><td valign=top>Replaces the last element in the index with value
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.modify(r, mod)
-</span></td><td valign=top>Executes <span class="d_inlinecode">mod(r.front)</span> and performs any necessary fixups to the
-container's indeces. If the result of mod violates any index' invariant,
-r.front is removed from the container.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.replace(r, value)
-</span></td><td valign=top>Replaces <span class="d_inlinecode">r.front</span> with <span class="d_inlinecode">value</span>.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.relocateFront(r, loc)
-</span></td><td valign=top>Moves <span class="d_inlinecode">r.front</span> to position before <span class="d_inlinecode">loc.front</span>.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.relocateBack(r, loc)
-</span></td><td valign=top>Moves <span class="d_inlinecode">r.back</span> to position after <span class="d_inlinecode">loc.back</span>.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insertFront(stuff)
-</span></td><td valign=top>Inserts stuff to the front of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insertBack(stuff)
-</span></td><td valign=top>Inserts stuff to the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insert(stuff)
-</span></td><td valign=top>Inserts stuff to the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeFront()
-</span></td><td valign=top>Removes the value at the front of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeBack()
-</span></td><td valign=top>Removes the value at the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeAny()
-</span></td><td valign=top>Removes the value at the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.remove(r)
-</span></td><td valign=top>Removes the values in range <span class="d_inlinecode">r</span> from the container.
-</td></tr>
-</table>
-<p></p>
-
-
-</td></tr>
-<p></p>
-
-
-<tr><th><span class="d_inlinecode">RandomAccess</span></th></tr>
-<tr><td valign=top>Provides a random access view - exposes an
-array-like access to container elements. Default insertion inserts to the back of the index <br>
-<p></p>
-
-
-Complexities:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><th></th> <th></th></tr>
-<tr><td valign=top>Insertion</td> <td valign=top>i(n) = 1 (amortized) for back insertion, n otherwise
-</td></tr>
-<tr><td valign=top>Removal</td> <td valign=top>d(n) = 1 for back removal, n otherwise
-</td></tr>
-<tr><td valign=top>Replacement</td> <td valign=top>r(n) = 1
-</td></tr></table>
-<p></p>
-
-
-Supported Operations:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><td valign=top><span class="d_inlinecode">c[]
-</span></td><td valign=top>Returns a random access range iterating over the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c[a .. b]
-</span></td><td valign=top>Returns a random access range iterating over the subrange of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.capacity
-</span></td><td valign=top>Returns the length of the underlying store of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.reserve(c)
-</span></td><td valign=top>Ensures sufficient capacity to accommodate <span class="d_inlinecode">c</span> elements
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.front
-</span></td><td valign=top>Returns the first element inserted into the index
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.front = value
-</span></td><td valign=top>Replaces the front element in the index with value
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.back
-</span></td><td valign=top>Returns the last element inserted into the index
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.back = value
-</span></td><td valign=top>Replaces the last element in the index with value
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c[i]
-</span></td><td valign=top>Provides const view random access to elements of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c[i] = value
-</span></td><td valign=top>Sets element <span class="d_inlinecode">i</span> to <span class="d_inlinecode">value</span>, unless another index refuses it.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.swapAt(i,j)
-</span></td><td valign=top>Swaps elements' positions in this index only. This can be done without checks!
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.modify(r, mod)
-</span></td><td valign=top>Executes <span class="d_inlinecode">mod(r.front)</span> and performs any necessary fixups to the
-container's indeces. If the result of mod violates any index' invariant,
-r.front is removed from the container.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.replace(r, value)
-</span></td><td valign=top>Replaces <span class="d_inlinecode">r.front</span> with <span class="d_inlinecode">value</span>.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insertFront(stuff)
-</span></td><td valign=top>Inserts stuff to the front of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insertBack(stuff)
-</span></td><td valign=top>Inserts stuff to the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insert(stuff)
-</span></td><td valign=top>Inserts stuff to the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeFront()
-</span></td><td valign=top>Removes the value at the front of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeBack()
-</span></td><td valign=top>Removes the value at the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeAny()
-</span></td><td valign=top>Removes the value at the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.linearRemove(r)
-</span></td><td valign=top>Removes the values in range <span class="d_inlinecode">r</span> from the container.
-</td></tr>
-</table>
-<p></p>
-
-
-</td></tr>
-<p></p>
-
-
-<tr><th><span class="d_inlinecode">Ordered, OrderedUnique, OrderedNonUnique</span></th></tr>
-<tr><td valign=top>Provides a
-red black tree view - keeps container elements in order defined by predicates
-KeyFromValue and Compare.
-Unique variant will cause the container to refuse
-insertion of an item if an equivalent item already exists in the container.
-<p></p>
-
-
-Complexities:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><th></th> <th></th></tr>
-<tr><td valign=top>Insertion</td> <td valign=top>i(n) = log(n) <br>
-</td></tr>
-<tr><td valign=top>Removal</td> <td valign=top>d(n) = log(n) <br>
-</td></tr>
-<tr><td valign=top>Replacement</td> <td valign=top>r(n) = 1 if the element's position does not change, log(n) otherwise
-</td></tr></table>
-<p></p>
-
-
-Supported Operations:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><td valign=top><span class="d_inlinecode">c[]
-</span></td><td valign=top>Returns a bidirectional range iterating over the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.front
-</span></td><td valign=top>Returns the first element inserted into the index
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.back
-</span></td><td valign=top>Returns the last element inserted into the index
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">k in c
-</span></td><td valign=top>Checks if <span class="d_inlinecode">k</span> is in the index, where <span class="d_inlinecode">k</span> is either an element or a key
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c[k]
-</span></td><td valign=top>Provides const view indexed access to elements of the index. Available for Unique variant.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.modify(r, mod)
-</span></td><td valign=top>Executes <span class="d_inlinecode">mod(r.front)</span> and performs any necessary fixups to the
-container's indeces. If the result of mod violates any index' invariant,
-r.front is removed from the container.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.replace(r, value)
-</span></td><td valign=top>Replaces <span class="d_inlinecode">r.front</span> with <span class="d_inlinecode">value</span>.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insert(stuff)
-</span></td><td valign=top>Inserts stuff into the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeFront()
-</span></td><td valign=top>Removes the value at the front of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeBack()
-</span></td><td valign=top>Removes the value at the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeAny()
-</span></td><td valign=top>Removes the value at the back of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.remove(r)
-</span></td><td valign=top>Removes the values in range <span class="d_inlinecode">r</span> from the container.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeKey(stuff)
-</span></td><td valign=top>Removes values equivalent to the given values or keys.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.upperBound(k)
-</span></td><td valign=top>Get a range with all elements <span class="d_inlinecode">e</span> such that <span class="d_inlinecode">e &lt; k</span>
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.lowerBound(k)
-</span></td><td valign=top>Get a range with all elements <span class="d_inlinecode">e</span> such that <span class="d_inlinecode">e &gt; k</span>
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.equalRange(k)
-</span></td><td valign=top>Get a range with all elements <span class="d_inlinecode">e</span> such that <span class="d_inlinecode">e == k</span>
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.bounds!("[]")(lo,hi)
-</span></td><td valign=top>Get a range with all elements <span class="d_inlinecode">e</span> such that <span class="d_inlinecode">lo &lt;= e &lt;= hi</span>. Boundaries parameter a la <a href="http://www.d-programming-language.org/phobos/std_random.html#uniform">std.random.uniform</a>!
-</td></tr>
-</table>
-<p></p>
-
-
-</td></tr>
-<p></p>
-
-
-<tr><th><span class="d_inlinecode">Hashed, HashedUnique, HashedNonUnique</span></th></tr>
-<tr><td valign=top>Provides a
-hash table view - exposes fast access to every element of the container,
-given key defined by predicates KeyFromValue, Hash, and Eq.
-Unique variant will cause the container to refuse
-insertion of an item if an equivalent item already exists in the container.
-<p></p>
-
-
-Complexities:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><th></th> <th></th></tr>
-<tr><td valign=top>Insertion</td> <td valign=top>i(n) = 1 average, n worst case <br>
-</td></tr>
-<tr><td valign=top>Removal</td> <td valign=top>d(n) = 1 for auxiliary removal, otherwise 1 average, n worst case <br>
-</td></tr>
-<tr><td valign=top>Replacement</td> <td valign=top>r(n) = 1 if the element's position does not change, log(n) otherwise
-</td></tr></table>
-<p></p>
-
-
-Supported Operations:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><td valign=top><span class="d_inlinecode">c[]
-</span></td><td valign=top>Returns a forward range iterating over the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.front
-</span></td><td valign=top>Returns the first element in the hash. No, this isn't helpful.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">k in c
-</span></td><td valign=top>Checks if <span class="d_inlinecode">k</span> is in the index, where <span class="d_inlinecode">k</span> is either an element or a key
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.contains(value)
-</span></td><td valign=top>Checks if <span class="d_inlinecode">value</span> is in the index. <br> EMN: Wat? Wat is this doing in here?
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c[k]
-</span></td><td valign=top>Provides const view indexed access to elements of the index. Available for Unique variant.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.modify(r, mod)
-</span></td><td valign=top>Executes <span class="d_inlinecode">mod(r.front)</span> and performs any necessary fixups to the
-container's indeces. If the result of mod violates any index' invariant,
-r.front is removed from the container.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.replace(r, value)
-</span></td><td valign=top>Replaces <span class="d_inlinecode">r.front</span> with <span class="d_inlinecode">value</span>.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insert(stuff)
-</span></td><td valign=top>Inserts stuff into the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.remove(r)
-</span></td><td valign=top>Removes the values in range <span class="d_inlinecode">r</span> from the container.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeKey(key)
-</span></td><td valign=top>Removes values equivalent to <span class="d_inlinecode">key</span>.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.equalRange(k)
-</span></td><td valign=top>Get a range with all elements <span class="d_inlinecode">e</span> such that <span class="d_inlinecode">e == k</span>
-</td></tr>
-</table>
-<p></p>
-
-
-</td></tr>
-<p></p>
-
-
-<tr><th><span class="d_inlinecode">Heap</span></th></tr>
-<tr><td valign=top>Provides a max heap view - exposes fast access to
-the largest element in the container as defined by predicates KeyFromValue
-and Compare.
-<p></p>
-
-
-Complexities:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><th></th> <th></th></tr>
-<tr><td valign=top>Insertion</td> <td valign=top>i(n) = log(n)
-</td></tr>
-<tr><td valign=top>Removal</td> <td valign=top>d(n) = log(n)
-</td></tr>
-<tr><td valign=top>Replacement</td> <td valign=top>r(n) = log(n) if the element's position does not change, log(n) otherwise
-</td></tr></table>
-Supported Operations:
-<table cellspacing=0 cellpadding=5 valign=top class=book><caption></caption><tr><td valign=top><span class="d_inlinecode">c[]
-</span></td><td valign=top>Returns a bidirectional (EMN: wat? why?!) range iterating over the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.front
-</span></td><td valign=top>Returns the max element in the heap.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.back
-</span></td><td valign=top>Returns some element of the heap.. probably not the max element...
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.modify(r, mod)
-</span></td><td valign=top>Executes <span class="d_inlinecode">mod(r.front)</span> and performs any necessary fixups to the
-container's indeces. If the result of mod violates any index' invariant,
-r.front is removed from the container.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.replace(r, value)
-</span></td><td valign=top>Replaces <span class="d_inlinecode">r.front</span> with <span class="d_inlinecode">value</span>.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.capacity
-</span></td><td valign=top>Returns the length of the underlying store of the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.reserve(c)
-</span></td><td valign=top>Ensures sufficient capacity to accommodate <span class="d_inlinecode">c</span> elements
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.insert(stuff)
-</span></td><td valign=top>Inserts stuff into the index.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeFront(stuff)
-</span></td><td valign=top>Removes the max element in the heap.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeAny(stuff)
-</span></td><td valign=top>Removes the max element in the heap.
-</td></tr>
-<tr><td valign=top><span class="d_inlinecode">c.removeBack(stuff)
-</span></td><td valign=top>Removes the back element in the heap. <br> EMN: what the heck was I smoking?
-</td></tr>
-</table>
-<p></p>
-
-
-</td></tr>
-<p></p>
-
-
-</table>
-
-<p></p>
+
+
+<br><br>
 <b>Mutability:</b><br>
 Providing multiple indeces to the same data does introduce some complexities,
 though. Consider:
-<pre class="d_code"><span class="d_keyword">class</span> Value{
-    <span class="d_keyword">int</span> i;
+<pre class="d_code"><font color=blue>class</font> Value{
+    <font color=blue>int</font> i;
     string s;
-    <span class="d_keyword">this</span>(<span class="d_keyword">int</span> _i, string _s){
+    <font color=blue>this</font>(<font color=blue>int</font> _i, string _s){
         i = _i;
         s = _s;
     }
 }
-<span class="d_keyword">alias</span> MultiIndexContainer!(Value,
-        IndexedBy!(RandomAccess!(), OrderedUnique!(<span class="d_string">"a.s"</span>))) C;
-
-C c = <span class="d_keyword">new</span> C;
-<span class="d_keyword">auto</span> i = c.get_index!0;
-
-i.insert(<span class="d_keyword">new</span> Value(1,<span class="d_string">"a"</span>));
-i.insert(<span class="d_keyword">new</span> Value(2,<span class="d_string">"b"</span>));
-i[1].s = <span class="d_string">"a"</span>; <span class="d_comment">// bad! index 1 now contains duplicates and is in invalid state!
-</span></pre>
+<font color=blue>alias</font> MultiIndexContainer!(Value,
+        IndexedBy!(RandomAccess!(), OrderedUnique!(<font color=red>"a.s"</font>))) C;
+
+C c = <font color=blue>new</font> C;
+<font color=blue>auto</font> i = c.get_index!0;
+
+i.insert(<font color=blue>new</font> Value(1,<font color=red>"a"</font>));
+i.insert(<font color=blue>new</font> Value(2,<font color=red>"b"</font>));
+i[1].s = <font color=red>"a"</font>; <font color=green>// bad! index 1 now contains duplicates and is in invalid state!
+</font></pre>
 In general, the container must either require the user not to perform any
 damning operation on its elements (which likely will entail paranoid and
 continual checking of the validity of its indeces), or else not provide
-a mutable view of its elements. By default, <a name="multi_index"></a><u>multi_index</u> chooses the
+a mutable view of its elements. By default, 
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script> chooses the
 latter (with controlled exceptions).
-<p></p>
-
+<br><br>
 
 Thus you are limited to modification operations for which the indeces can
 detect and perform any fixups (or possibly reject). You can use a
 remove/modify/insert workflow here, or functions modify and replace, which
 each index implements.
-<p></p>
-
+<br><br>
 
 For modifications which are sure not to invalidate any index, you might
 simply
 cast away the constness of the returned element. This will work,
 but it is not recommended on the grounds of aesthetics (it's ew) and
 maintainability (if the code changes, it's a ticking time bomb).
-<p></p>
-
+<br><br>
 
 Finally, if you just have to have a mutable view, include
 MutableView in the MultiIndexContainer specification. This is
-the least safe option (but see <span class="d_inlinecode">ValueChangedSlots</span>), and you might make
+the least safe option (but see ), and you might make
 liberal use of the convenience function check provided by
 MultiIndexContainer, which asserts the validity of each index.
 
-<p></p>
+<br><br>
 <b>Efficiency:</b><br>
 To draw on an example from boost::multi_index, suppose a collection of
 Tuple!(int,int) needs to be kept in sorted order by both elements of the tuple.
 This might be accomplished by the following:
-<pre class="d_code"><span class="d_keyword">import</span> std.container;
-<span class="d_keyword">alias</span> RedBlackTree!(Tuple!(<span class="d_keyword">int</span>,<span class="d_keyword">int</span>), <span class="d_string">"a[0] &lt; b[0]"</span>) T1;
-<span class="d_keyword">alias</span> RedBlackTree!(Tuple!(<span class="d_keyword">int</span>,<span class="d_keyword">int</span>)*, <span class="d_string">"(*a)[1] &lt; (*b)[1]"</span>) T2;
-
-T1 tree1 = <span class="d_keyword">new</span> T1;
-T2 tree2 = <span class="d_keyword">new</span> T2;
+<pre class="d_code"><font color=blue>import</font> std.container;
+<font color=blue>alias</font> RedBlackTree!(Tuple!(<font color=blue>int</font>,<font color=blue>int</font>), <font color=red>"a[0] &lt; b[0]"</font>) T1;
+<font color=blue>alias</font> RedBlackTree!(Tuple!(<font color=blue>int</font>,<font color=blue>int</font>)*, <font color=red>"(*a)[1] &lt; (*b)[1]"</font>) T2;
+
+T1 tree1 = <font color=blue>new</font> T1;
+T2 tree2 = <font color=blue>new</font> T2;
 </pre>
 
 Insertion remains straightforward
 </pre>
 However removal introduces some inefficiency
 <pre class="d_code">tree1.remove(item);
-tree2.remove(&amp;item); <span class="d_comment">// requires a log(n) search, followed by a potential log(n) rebalancing
-</span></pre>
+tree2.remove(&amp;item); <font color=green>// requires a log(n) search, followed by a potential log(n) rebalancing
+</font></pre>
 Muñoz suggests making the element type of T2 an iterator of T1 for to obviate
 the need for the second search. However, this is not possible in D, as D
 espouses ranges rather than indeces. (As a side note, Muñoz proceeds to point
 out that the iterator solution will require at minimum (N * ptrsize) more bytes
 of memory than will multi_index, so we needn't lament over this fact.)
-<p></p>
-
+<br><br>
 
 Our approach:
-<pre class="d_code"><span class="d_keyword">alias</span> MultiIndexContainer!(Tuple!(<span class="d_keyword">int</span>,<span class="d_keyword">int</span>),
-        IndexedBy!(OrderedUnique!(<span class="d_string">"a[0]"</span>),
-            OrderedUnique!(<span class="d_string">"a[1]"</span>))) T;
-
-T t = <span class="d_keyword">new</span> T;
+<pre class="d_code"><font color=blue>alias</font> MultiIndexContainer!(Tuple!(<font color=blue>int</font>,<font color=blue>int</font>),
+        IndexedBy!(OrderedUnique!(<font color=red>"a[0]"</font>),
+            OrderedUnique!(<font color=red>"a[1]"</font>))) T;
+
+T t = <font color=blue>new</font> T;
 </pre>
 
 makes insertion and removal somewhat simpler:
-<p></p>
-
+<br><br>
 
 <pre class="d_code">t.insert(item);
 t.remove(item);
 and removal will not perform a log(n) search on the second index
 (rebalancing can't be avoided).
 
-<p></p>
+<br><br>
 <b>Signals and Slots:</b><br>
-An experimental feature of <a name="multi_index"></a><u>multi_index</u>.
-<p></p>
-
+An experimental feature of 
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script>.
+<br><br>
 
 You can receive signals from MultiIndexContainer. Someday. Maybe.
-<p></p>
-
+<br><br>
 
 Provided signals:
-<p></p>
-
+<br><br>
 
 *crickets*
-<p></p>
-
+<br><br>
 
 You can design your value type to signal to MultiIndexContainer.
-<p></p>
-
-
-(Note: std.signals won't work with <a name="multi_index"></a><u>multi_index</u>,
+<br><br>
+
+(Note: std.signals won't work with 
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script>,
 so don't bother trying)
-<p></p>
-
+<br><br>
 
 Provided slots:
-<p></p>
-
+<br><br>
 
 ValueChangedSlots - MultiIndexContainer receives signals from a value when value is mutated such that its position in an index may have changed.
 
-<p></p>
+<br><br>
 <b>Example:</b><br>
 <pre class="d_code">
-<span class="d_keyword">import</span> <span class="d_psymbol">multi_index</span>;
-<span class="d_keyword">import</span> std.algorithm: moveAll;
-
-<span class="d_keyword">class</span> MyRecord{
-    <span class="d_keyword">int</span> _i;
-
-    @property <span class="d_keyword">int</span> i()<span class="d_keyword">const</span>{ <span class="d_keyword">return</span> _i; }
-    @property <span class="d_keyword">void</span> i(<span class="d_keyword">int</span> i1){
+<font color=blue>import</font> <u>multi_index</u>;
+<font color=blue>import</font> std.algorithm: moveAll;
+
+<font color=blue>class</font> MyRecord{
+    <font color=blue>int</font> _i;
+
+    @property <font color=blue>int</font> i()<font color=blue>const</font>{ <font color=blue>return</font> _i; }
+    @property <font color=blue>void</font> i(<font color=blue>int</font> i1){
         _i = i1;
-        emit(); <span class="d_comment">// MultiIndexContainer is notified that this record's
-</span>                <span class="d_comment">// position in indeces may need to be fixed
-</span>    }
-
-    <span class="d_comment">// signal impl - MultiIndexContainer will use these
-</span>    <span class="d_comment">// to connect. In this example, we actually only need
-</span>    <span class="d_comment">// a single slot. For a value type with M signals
-</span>    <span class="d_comment">// (differentiated with mixin aliases), there will be
-</span>    <span class="d_comment">// M slots connected.
-</span>    <span class="d_keyword">mixin</span> Signals!();
+        emit(); <font color=green>// MultiIndexContainer is notified that this record's
+</font>                <font color=green>// position in indeces may need to be fixed
+</font>    }
+
+    <font color=green>// signal impl - MultiIndexContainer will use these
+</font>    <font color=green>// to connect. In this example, we actually only need
+</font>    <font color=green>// a single slot. For a value type with M signals
+</font>    <font color=green>// (differentiated with mixin aliases), there will be
+</font>    <font color=green>// M slots connected.
+</font>    <font color=blue>mixin</font> Signals!();
 }
 
-<span class="d_keyword">alias</span> MultiIndexContainer!(MyRecord,
-    IndexedBy!(OrderedUnique!(<span class="d_string">"a.i"</span>)),
-    ValueChangedSlots!(ValueSignal!(0)), <span class="d_comment">// this tells MultiIndexContainer that you want
-</span>                                      <span class="d_comment">// it to use the signal defined in MyRecord.
-</span>                                      <span class="d_comment">// you just need to pass in the index number.
-</span>    MutableView,
+<font color=blue>alias</font> MultiIndexContainer!(MyRecord,
+    IndexedBy!(OrderedUnique!(<font color=red>"a.i"</font>)),
+    ValueChangedSlots!(ValueSignal!(0)), <font color=green>// this tells MultiIndexContainer that you want
+</font>                                      <font color=green>// it to use the signal defined in MyRecord.
+</font>                                      <font color=green>// you just need to pass in the index number.
+</font>    MutableView,
 ) MyContainer;
 
-MyContainer c = <span class="d_keyword">new</span> MyContainer;
-
-<span class="d_comment">// populate c
-</span>
+MyContainer c = <font color=blue>new</font> MyContainer;
+
+<font color=green>// populate c
+</font>
 MyRecord v = c.front();
 
-v.i = 22; <span class="d_comment">// v's position in c is automatically fixed
-</span></pre>
+v.i = 22; <font color=green>// v's position in c is automatically fixed
+</font></pre>
 
 Thus, MultiIndexContainers can be kept valid automatically PROVIDED no
 modifications occur other than those succeeded by a call to emit.
-<p></p>
-
+<br><br>
 
 But what happens if a modification breaks, for example, a uniqueness
 constraint? Well, you have two options: remove the offending element
-silently, or remove it loudly (throw an exception). <a name="multi_index"></a><u>multi_index</u> chooses
+silently, or remove it loudly (throw an exception). 
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script> chooses
 the latter in this case.
-<p></p>
-
+<br><br>
 
 <b>Thread Safety</b>:
-<p></p>
-
-
-<a name="multi_index"></a><u>multi_index</u> is not designed to be used in multithreading.
+<br><br>
+
+
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script> is not designed to be used in multithreading.
 Find yourself a relational database.
-<p></p>
-
+<br><br>
 
 <b>Memory Allocation</b>
-<p></p>
-
-
-In C++, memory allocators are used to control how a container allocates memory. D does not have a standardized allocator interface (but will soon). Until it does, <a name="multi_index"></a><u>multi_index</u> will use a
+<br><br>
+
+In C++, memory allocators are used to control how a container allocates memory. D does not have a standardized allocator interface (but will soon). Until it does, 
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script> will use a
 simple allocator protocol to regulate allocation of container structures.
 Define a struct with two static methods:
-<p></p>
-
-
-<pre class="d_code"><span class="d_keyword">struct</span> MyAllocator{
- T* allocate(T)(size_t i); <span class="d_comment">// return pointer to chunk of memory containing i*T.sizeof bytes
-</span> <span class="d_keyword">void</span> deallocate(T)(T* t); <span class="d_comment">// release chunk of memory at t
-</span>}
+<br><br>
+
+<pre class="d_code"><font color=blue>struct</font> MyAllocator{
+ T* allocate(T)(size_t i); <font color=green>// return pointer to chunk of memory containing i*T.sizeof bytes
+</font> <font color=blue>void</font> deallocate(T)(T* t); <font color=green>// release chunk of memory at t
+</font>}
 </pre>
 Pass the struct type in to MultiIndexContainer:
-<pre class="d_code"><span class="d_keyword">alias</span> MultiIndexContainer!(<span class="d_keyword">int</span>,IndexedBy!(Sequenced!()), MyAllocator) G;
+<pre class="d_code"><font color=blue>alias</font> MultiIndexContainer!(<font color=blue>int</font>,IndexedBy!(Sequenced!()), MyAllocator) G;
 </pre>
-Two allocators are predefined in <a name="multi_index"></a><u>multi_index</u>: <b>GCAllocator</b> (default), and <b>MallocAllocator</b><p></p>
-
-<dl><dt><div class="d_decl">template <a name="Sequenced"></a><u>Sequenced</u>()</div></dt>
-<dd>A doubly linked list index.<p></p>
-
-<dl><dt><div class="d_decl">struct <a name="SequencedRange"></a><u>SequencedRange</u>(bool is_const);
-</div></dt>
+Two allocators are predefined in 
+<span class="currsymbol">multi_index</span>
+<script>explorer.outline.addDecl('multi_index');</script>: <b>GCAllocator</b> (default), and <b>MallocAllocator</b>
+
+<br><br>
+<b>Compatible Sorting Criteria:</b><br>
+Loosely, predicates C1 and C2 are compatible if a sequence sorted by C1 is
+also sorted by C2 (consult
+<a
+href="http://www.boost.org/doc/libs/1_50_0/libs/multi_index/doc/reference/ord_indices.html#set_operations"
+>
+multi_index
+</a> for a more complete definition).
+<br><br>
+
+For (KeyType, CompatibleKeyType), a compatible sorting criterion
+takes the form:
+<pre class="d_code"><font color=blue>struct</font> CompatibleLess{
+    <font color=blue>static</font>:
+    <font color=blue>bool</font> kc_less(KeyType, CompatibleKeyType);
+    <font color=blue>bool</font> ck_less(CompatibleKeyType, KeyType);
+    <font color=blue>bool</font> cc_less(CompatibleKeyType, CompatibleKeyType);
+}
+</pre>
+<br><br>
+
+
+<script>explorer.outline.incSymbolLevel();</script>
+<dl>
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">template 
+<span class="currsymbol">Sequenced</span>
+<script>explorer.outline.addDecl('Sequenced');</script>()</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>A doubly linked list index.<br><br>
+
+
+<script>explorer.outline.incSymbolLevel();</script>
+<dl>
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">struct 
+<span class="currsymbol">SequencedRange</span>
+<script>explorer.outline.addDecl('SequencedRange');</script>(bool is_const);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
 <dd>Defines the index' primary range, which embodies a
-bidirectional range<p></p>
-
-<dl><dt><div class="d_decl">bool <a name="empty"></a><u>empty</u>();
-</div></dt>
-<dd><p></p>
+bidirectional range<br><br>
+
+
+<script>explorer.outline.incSymbolLevel();</script>
+<dl>
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">bool 
+<span class="currsymbol">empty</span>
+<script>explorer.outline.addDecl('empty');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
 
 </dd>
-<dt><div class="d_decl">@property auto <a name="front"></a><u>front</u>();
-</div></dt>
-<dd><p></p>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">@property auto 
+<span class="currsymbol">front</span>
+<script>explorer.outline.addDecl('front');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
 
 </dd>
-<dt><div class="d_decl">@property auto <a name="back"></a><u>back</u>();
-</div></dt>
-<dd><p></p>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">@property auto 
+<span class="currsymbol">back</span>
+<script>explorer.outline.addDecl('back');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
 
 </dd>
-<dt><div class="d_decl">@property auto <a name="save"></a><u>save</u>();
-</div></dt>
-<dd><p></p>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">@property auto 
+<span class="currsymbol">save</span>
+<script>explorer.outline.addDecl('save');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
 
 </dd>
-<dt><div class="d_decl">void <a name="popFront"></a><u>popFront</u>();
-</div></dt>
-<dd><p></p>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">popFront</span>
+<script>explorer.outline.addDecl('popFront');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
 
 </dd>
-<dt><div class="d_decl">void <a name="popBack"></a><u>popBack</u>();
-</div></dt>
-<dd><p></p>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">popBack</span>
+<script>explorer.outline.addDecl('popBack');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
 
 </dd>
-<dt><div class="d_decl">void <a name="removeFront"></a><u>removeFront</u>();
-</div></dt>
+</dl>
+<script>explorer.outline.decSymbolLevel();</script>
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">alias 
+<span class="currsymbol">SeqRange</span>
+<script>explorer.outline.addDecl('SeqRange');</script>;
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">alias 
+<span class="currsymbol">ConstSeqRange</span>
+<script>explorer.outline.addDecl('ConstSeqRange');</script>;
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">const size_t 
+<span class="currsymbol">length</span>
+<script>explorer.outline.addDecl('length');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Returns the number of elements in the container.
+<br><br>
+<b>Complexity:</b><br>
+.<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">const bool 
+<span class="currsymbol">empty</span>
+<script>explorer.outline.addDecl('empty');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Property returning  if and only if the container has no
+elements.
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">SeqRange 
+<span class="currsymbol">opSlice</span>
+<script>explorer.outline.addDecl('opSlice');</script>();
+<br>const ConstSeqRange 
+<span class="currsymbol">opSlice</span>
+<script>explorer.outline.addDecl('opSlice');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Fetch a range that spans all the elements in the container.
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">inout @property auto 
+<span class="currsymbol">front</span>
+<script>explorer.outline.addDecl('front');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">front</span>
+<script>explorer.outline.addDecl('front');</script>(Value <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Complexity:</b><br>
+; <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">inout @property auto 
+<span class="currsymbol">back</span>
+<script>explorer.outline.addDecl('back');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">back</span>
+<script>explorer.outline.addDecl('back');</script>(Value <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">relocateFront</span>
+<script>explorer.outline.addDecl('relocateFront');</script>(PosRange)(ref PosRange <span class="funcparam">moveme</span>, PosRange <span class="funcparam">tohere</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Moves moveme.front to the position before tohere.front and increments moveme.
+Takes either a range from this index, or any positional range originating
+from this index.
+<br><br>
+<b>Preconditions:</b><br>
+moveme and tohere are both ranges of the same container
+<br><br>
+<b>Postconditions:</b><br>
+moveme is incremented
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">relocateBack</span>
+<script>explorer.outline.addDecl('relocateBack');</script>(PosRange)(ref PosRange <span class="funcparam">moveme</span>, PosRange <span class="funcparam">tohere</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Moves moveme.back to the position after tohere.back and decrements moveme.
+Takes either a range from this index, or any positional range originating
+from this index.
+<br><br>
+<b>Preconditions:</b><br>
+moveme and tohere are both ranges of the same container
+<br><br>
+<b>Postconditions:</b><br>
+moveme.back is decremented
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">modify</span>
+<script>explorer.outline.addDecl('modify');</script>(SomeRange, Modifier)(SomeRange <span class="funcparam">r</span>, Modifier <span class="funcparam">mod</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Perform mod on elements of r and performs any necessary fixups to container's
+indeces. If the result of mod violates any index' invariant, the element is
+removed from the container.
+<br><br>
+<b>Preconditions:</b><br>
+mod is a callable of the form void mod(ref Value)
+<br><br>
+<b>Complexity:</b><br>
+, <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">bool 
+<span class="currsymbol">replace</span>
+<script>explorer.outline.addDecl('replace');</script>(Position!(ThisNode) <span class="funcparam">r</span>, Value <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Replaces <span class="funcparam">value</span> at <span class="funcparam">r</span> with <span class="funcparam">value</span>
+<br><br>
+<b>Returns:</b><br>
+whether replacement succeeded
+<br><br>
+<b>Complexity:</b><br>
+??<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">size_t 
+<span class="currsymbol">insertFront</span>
+<script>explorer.outline.addDecl('insertFront');</script>(SomeRange)(SomeRange <span class="funcparam">stuff</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Inserts every element of stuff not rejected by another index into the front
+of the index.
+<br><br>
+<b>Returns:</b><br>
+The number of elements inserted.
+<br><br>
+<b>Complexity:</b><br>
+; <br>  for
+this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">size_t 
+<span class="currsymbol">insertFront</span>
+<script>explorer.outline.addDecl('insertFront');</script>(SomeValue)(SomeValue <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Inserts value into the front of the sequence, if no other index rejects value
+<br><br>
+<b>Returns:</b><br>
+The number if elements inserted into the index.
+<br><br>
+<b>Complexity:</b><br>
+; <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">size_t 
+<span class="currsymbol">insertBack</span>
+<script>explorer.outline.addDecl('insertBack');</script>(SomeRange)(SomeRange <span class="funcparam">stuff</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Inserts every element of stuff not rejected by another index into the back
+of the index.
+<br><br>
+<b>Returns:</b><br>
+The number of elements inserted.
+<br><br>
+<b>Complexity:</b><br>
+; <br>  for
+this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">size_t 
+<span class="currsymbol">insertBack</span>
+<script>explorer.outline.addDecl('insertBack');</script>(SomeValue)(SomeValue <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Inserts value into the back of the sequence, if no other index rejects value
+<br><br>
+<b>Returns:</b><br>
+The number if elements inserted into the index.
+<br><br>
+<b>Complexity:</b><br>
+; <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">alias 
+<span class="currsymbol">insert</span>
+<script>explorer.outline.addDecl('insert');</script>;
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Forwards to insertBack<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">removeFront</span>
+<script>explorer.outline.addDecl('removeFront');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Removes the value at the front of the index from the container.
+<br><br>
+<b>Precondition:</b><br>
+
+<br><br>
+<b>Complexity:</b><br>
+;  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">removeBack</span>
+<script>explorer.outline.addDecl('removeBack');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Removes the value at the back of the index from the container.
+<br><br>
+<b>Precondition:</b><br>
+
+<br><br>
+<b>Complexity:</b><br>
+; <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">alias 
+<span class="currsymbol">removeAny</span>
+<script>explorer.outline.addDecl('removeAny');</script>;
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Forwards to removeBack<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">SeqRange 
+<span class="currsymbol">remove</span>
+<script>explorer.outline.addDecl('remove');</script>(R)(R <span class="funcparam">r</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Removes the values of r from the container.
+Takes either a range from this index, or any positional range originating
+from this index.
+<br><br>
+<b>Returns:</b><br>
+an empty range (EMN: why?)
+<br><br>
+<b>Preconditions:</b><br>
+r came from this index
+<br><br>
+<b>Complexity:</b><br>
+, <br>  for this index<br><br>
+
+</dd>
+</dl>
+<script>explorer.outline.decSymbolLevel();</script>
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">template 
+<span class="currsymbol">RandomAccess</span>
+<script>explorer.outline.addDecl('RandomAccess');</script>()</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>A random access index.<br><br>
+
+
+<script>explorer.outline.incSymbolLevel();</script>
+<dl>
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">struct 
+<span class="currsymbol">RARangeT</span>
+<script>explorer.outline.addDecl('RARangeT');</script>(bool is_const);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Defines the index' primary range, which embodies a
+ random access range <br><br>
+
+
+<script>explorer.outline.incSymbolLevel();</script>
+<dl>
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">@property auto 
+<span class="currsymbol">front</span>
+<script>explorer.outline.addDecl('front');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">popFront</span>
+<script>explorer.outline.addDecl('popFront');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">const bool 
+<span class="currsymbol">empty</span>
+<script>explorer.outline.addDecl('empty');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">const size_t 
+<span class="currsymbol">length</span>
+<script>explorer.outline.addDecl('length');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">@property auto 
+<span class="currsymbol">back</span>
+<script>explorer.outline.addDecl('back');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">popBack</span>
+<script>explorer.outline.addDecl('popBack');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">@property auto 
+<span class="currsymbol">save</span>
+<script>explorer.outline.addDecl('save');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">auto 
+<span class="currsymbol">opIndex</span>
+<script>explorer.outline.addDecl('opIndex');</script>(size_t <span class="funcparam">i</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+</dl>
+<script>explorer.outline.decSymbolLevel();</script>
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">RARange 
+<span class="currsymbol">opSlice</span>
+<script>explorer.outline.addDecl('opSlice');</script>();
+<br>const ConstRARange 
+<span class="currsymbol">opSlice</span>
+<script>explorer.outline.addDecl('opSlice');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Fetch a range that spans all the elements in the container.
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">RARange 
+<span class="currsymbol">opSlice</span>
+<script>explorer.outline.addDecl('opSlice');</script>(size_t <span class="funcparam">a</span>, size_t <span class="funcparam">b</span>);
+<br>const ConstRARange 
+<span class="currsymbol">opSlice</span>
+<script>explorer.outline.addDecl('opSlice');</script>(size_t <span class="funcparam">a</span>, size_t <span class="funcparam">b</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Fetch <span class="funcparam">a</span> range that spans all the elements in the container from
+index  (inclusive) to index  (exclusive).
+<br><br>
+<b>Preconditions:</b><br>
+<span class="funcparam">a</span> &lt;= <span class="funcparam">b</span> &amp;&amp; <span class="funcparam">b</span> &lt;= length
+
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">const size_t 
+<span class="currsymbol">length</span>
+<script>explorer.outline.addDecl('length');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Returns the number of elements in the container.
+<br><br>
+<b>Complexity:</b><br>
+.<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">const bool 
+<span class="currsymbol">empty</span>
+<script>explorer.outline.addDecl('empty');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Property returning  if and only if the container has no elements.
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">const size_t 
+<span class="currsymbol">capacity</span>
+<script>explorer.outline.addDecl('capacity');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Returns the capacity of the index, which is the length of the
+underlying store<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">reserve</span>
+<script>explorer.outline.addDecl('reserve');</script>(size_t <span class="funcparam">count</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Ensures sufficient capacity to accommodate  elements.
+<br><br>
+<b>Postcondition:</b><br>
+
+
+<br><br>
+<b>Complexity:</b><br>
+ if ,
+otherwise .<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">inout @property auto 
+<span class="currsymbol">front</span>
+<script>explorer.outline.addDecl('front');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">front</span>
+<script>explorer.outline.addDecl('front');</script>(ValueView <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Complexity:</b><br>
+; <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">inout @property auto 
+<span class="currsymbol">back</span>
+<script>explorer.outline.addDecl('back');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">back</span>
+<script>explorer.outline.addDecl('back');</script>(ValueView <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Complexity:</b><br>
+; <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">clear</span>
+<script>explorer.outline.addDecl('clear');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">inout auto 
+<span class="currsymbol">opIndex</span>
+<script>explorer.outline.addDecl('opIndex');</script>(size_t <span class="funcparam">i</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd><b>Preconditions:</b><br>
+<span class="funcparam">i</span> &lt; length
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">ValueView 
+<span class="currsymbol">opIndexAssign</span>
+<script>explorer.outline.addDecl('opIndexAssign');</script>(ValueView <span class="funcparam">value</span>, size_t <span class="funcparam">i</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Sets index <span class="funcparam">i</span> to <span class="funcparam">value</span>, unless another index refuses <span class="funcparam">value</span>
+<br><br>
+<b>Preconditions:</b><br>
+<span class="funcparam">i</span> &lt; length
+<br><br>
+<b>Returns:</b><br>
+the resulting value at index <span class="funcparam">i</span>
+<br><br>
+<b>Complexity:</b><br>
+; <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">swapAt</span>
+<script>explorer.outline.addDecl('swapAt');</script>(size_t <span class="funcparam">i</span>, size_t <span class="funcparam">j</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Swaps element at index  with element at index .
+<br><br>
+<b>Preconditions:</b><br>
+<span class="funcparam">i</span> &lt; length &amp;&amp; <span class="funcparam">j</span> &lt; length
+<br><br>
+<b>Complexity:</b><br>
+<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">removeBack</span>
+<script>explorer.outline.addDecl('removeBack');</script>();
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Removes the last element from this index.
+<br><br>
+<b>Preconditions:</b><br>
+!empty
+<br><br>
+<b>Complexity:</b><br>
+; <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">size_t 
+<span class="currsymbol">insertBack</span>
+<script>explorer.outline.addDecl('insertBack');</script>(SomeValue)(SomeValue <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>inserts value in the back of this index.
+<br><br>
+<b>Complexity:</b><br>
+, <br> amortized  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">size_t 
+<span class="currsymbol">insertBack</span>
+<script>explorer.outline.addDecl('insertBack');</script>(SomeRange)(SomeRange <span class="funcparam">r</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>inserts elements of r in the back of this index.
+<br><br>
+<b>Complexity:</b><br>
+, <br> amortized 
+for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">alias 
+<span class="currsymbol">insert</span>
+<script>explorer.outline.addDecl('insert');</script>;
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>inserts elements of r in the back of this index.
+<br><br>
+<b>Complexity:</b><br>
+, <br> amortized 
+for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">void 
+<span class="currsymbol">modify</span>
+<script>explorer.outline.addDecl('modify');</script>(SomeRange, Modifier)(SomeRange <span class="funcparam">r</span>, Modifier <span class="funcparam">mod</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Perform mod on elements of r and performs any necessary fixups to container's
+indeces. If the result of mod violates any index' invariant, the element is
+removed from the container.
+<br><br>
+<b>Preconditions:</b><br>
+mod is a callable of the form void mod(ref Value)
+<br><br>
+<b>Complexity:</b><br>
+, <br>  for this index<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">bool 
+<span class="currsymbol">replace</span>
+<script>explorer.outline.addDecl('replace');</script>(Position!(ThisNode) <span class="funcparam">r</span>, ValueView <span class="funcparam">value</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Replaces the <span class="funcparam">value</span> at <span class="funcparam">r</span> with <span class="funcparam">value</span>
+<br><br>
+<b>Returns:</b><br>
+whether replacement succeeded
+<br><br>
+<b>Complexity:</b><br>
+??<br><br>
+
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">RARange 
+<span class="currsymbol">remove</span>
+<script>explorer.outline.addDecl('remove');</script>(Range)(Range <span class="funcparam">r</span>);
+</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>Removes elements of r from this container.
+Takes either a range from this index, or any positional range originating
+from this index.
+<br><br>
+<b>Returns:</b><br>
+An empty range.
+<br><br>
+<b>Complexity:</b><br>
+, <br> 
+for this index<br><br>
+
+</dd>
+</dl>
+<script>explorer.outline.decSymbolLevel();</script>
+</dd>
+
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">template 
+<span class="currsymbol">Ordered</span>
+<script>explorer.outline.addDecl('Ordered');</script>(bool allowDuplicates = false,alias KeyFromValue = "a",alias Compare = "a&lt;b")</span></dt>
+<script>explorer.outline.writeEnabled = false;</script>
+<dd>A red black tree index<br><br>
+
+
+<script>explorer.outline.incSymbolLevel();</script>
+<dl>
+<script>explorer.outline.writeEnabled = true;</script>
+<dt><span class="decl">struct 
+<span class="currsymbol">OrderedRan