RONCC
/
HPC-Tools-for-Quantum-Computing


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374
							<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="generator" content="rustdoc">
    <meta name="description" content="API documentation for the Rust `synom` crate.">
    <meta name="keywords" content="rust, rustlang, rust-lang, synom">

    <title>synom - Rust</title>

    <link rel="stylesheet" type="text/css" href="../normalize.css">
    <link rel="stylesheet" type="text/css" href="../rustdoc.css" id="mainThemeStyle">
    
    <link rel="stylesheet" type="text/css" href="../dark.css">
    <link rel="stylesheet" type="text/css" href="../main.css" id="themeStyle">
    <script src="../storage.js"></script>
    

    
    
</head>
<body class="rustdoc mod">
    <!--[if lte IE 8]>
    <div class="warning">
        This old browser is unsupported and will most likely display funky
        things.
    </div>
    <![endif]-->

    

    <nav class="sidebar">
        <div class="sidebar-menu">&#9776;</div>
        
        <p class='location'>Crate synom</p><div class="sidebar-elems"><div class="block items"><ul><li><a href="#macros">Macros</a></li><li><a href="#enums">Enums</a></li></ul></div><p class='location'></p><script>window.sidebarCurrent = {name: 'synom', ty: 'mod', relpath: '../'};</script></div>
    </nav>

    <div class="theme-picker">
        <button id="theme-picker" aria-label="Pick another theme!">
            <img src="../brush.svg" width="18" alt="Pick another theme!">
        </button>
        <div id="theme-choices"></div>
    </div>
    <script src="../theme.js"></script>
    <nav class="sub">
        <form class="search-form js-only">
            <div class="search-container">
                <input class="search-input" name="search"
                       autocomplete="off"
                       placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
                       type="search">
            </div>
        </form>
    </nav>

    <section id='main' class="content">
<h1 class='fqn'><span class='in-band'>Crate <a class="mod" href=''>synom</a></span><span class='out-of-band'><span id='render-detail'>
                   <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
                       [<span class='inner'>&#x2212;</span>]
                   </a>
               </span><a class='srclink' href='../src/synom/lib.rs.html#1-1225' title='goto source code'>[src]</a></span></h1>
<div class='docblock'><p>Adapted from <a href="https://github.com/Geal/nom"><code>nom</code></a> by removing the
<code>IResult::Incomplete</code> variant which:</p>
<ul>
<li>we don't need,</li>
<li>is an unintuitive footgun when working with non-streaming use cases, and</li>
<li>more than doubles compilation time.</li>
</ul>
<h2 id="whitespace-handling-strategy" class="section-header"><a href="#whitespace-handling-strategy">Whitespace handling strategy</a></h2>
<p>As (sy)nom is a parser combinator library, the parsers provided here and
that you implement yourself are all made up of successively more primitive
parsers, eventually culminating in a small number of fundamental parsers
that are implemented in Rust. Among these are <code>punct!</code> and <code>keyword!</code>.</p>
<p>All synom fundamental parsers (those not combined out of other parsers)
should be written to skip over leading whitespace in their input. This way,
as long as every parser eventually boils down to some combination of
fundamental parsers, we get correct whitespace handling at all levels for
free.</p>
<p>For our use case, this strategy is a huge improvement in usability,
correctness, and compile time over nom's <code>ws!</code> strategy.</p>
</div><h2 id='macros' class='section-header'><a href="#macros">Macros</a></h2>
<table>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.alt.html"
                                  title='macro synom::alt'>alt</a></td>
                           <td class='docblock-short'>
                                <p>Run a series of parsers, returning the result of the first one which
succeeds.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.call.html"
                                  title='macro synom::call'>call</a></td>
                           <td class='docblock-short'>
                                <p>Invoke the given parser function with the passed in arguments.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.cond.html"
                                  title='macro synom::cond'>cond</a></td>
                           <td class='docblock-short'>
                                <p>Conditionally execute the given parser.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.cond_reduce.html"
                                  title='macro synom::cond_reduce'>cond_reduce</a></td>
                           <td class='docblock-short'>
                                <p>Fail to parse if condition is false, otherwise parse the given parser.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.delimited.html"
                                  title='macro synom::delimited'>delimited</a></td>
                           <td class='docblock-short'>
                                <p>Value surrounded by a pair of delimiters.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.do_parse.html"
                                  title='macro synom::do_parse'>do_parse</a></td>
                           <td class='docblock-short'>
                                <p>Run a series of parsers, one after another, optionally assigning the results
a name. Fail if any of the parsers fails.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.epsilon.html"
                                  title='macro synom::epsilon'>epsilon</a></td>
                           <td class='docblock-short'>
                                <p>Parses nothing and always succeeds.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.keyword.html"
                                  title='macro synom::keyword'>keyword</a></td>
                           <td class='docblock-short'>
                                <p>Parse a keyword like &quot;fn&quot; or &quot;struct&quot;.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.many0.html"
                                  title='macro synom::many0'>many0</a></td>
                           <td class='docblock-short'>
                                <p>Parse zero or more values using the given parser.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.map.html"
                                  title='macro synom::map'>map</a></td>
                           <td class='docblock-short'>
                                <p>Transform the result of a parser by applying a function or closure.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.named.html"
                                  title='macro synom::named'>named</a></td>
                           <td class='docblock-short'>
                                <p>Define a function from a parser combination.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.not.html"
                                  title='macro synom::not'>not</a></td>
                           <td class='docblock-short'>
                                <p>Parses successfully if the given parser fails to parse. Does not consume any
of the input.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.opt_vec.html"
                                  title='macro synom::opt_vec'>opt_vec</a></td>
                           <td class='docblock-short'>
                                <p>Turn a failed parse into an empty vector. The argument parser must itself
return a vector.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.option.html"
                                  title='macro synom::option'>option</a></td>
                           <td class='docblock-short'>
                                <p>Turn a failed parse into <code>None</code> and a successful parse into <code>Some</code>.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.peek.html"
                                  title='macro synom::peek'>peek</a></td>
                           <td class='docblock-short'>
                                <p>Parse a value without consuming it from the input data.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.preceded.html"
                                  title='macro synom::preceded'>preceded</a></td>
                           <td class='docblock-short'>
                                <p>Parse two things, returning the value of the second.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.punct.html"
                                  title='macro synom::punct'>punct</a></td>
                           <td class='docblock-short'>
                                <p>Parse a piece of punctuation like &quot;+&quot; or &quot;+=&quot;.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.separated_list.html"
                                  title='macro synom::separated_list'>separated_list</a></td>
                           <td class='docblock-short'>
                                <p>Zero or more values separated by some separator. Does not allow a trailing
seperator.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.separated_nonempty_list.html"
                                  title='macro synom::separated_nonempty_list'>separated_nonempty_list</a></td>
                           <td class='docblock-short'>
                                <p>One or more values separated by some separator. Does not allow a trailing
separator.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.switch.html"
                                  title='macro synom::switch'>switch</a></td>
                           <td class='docblock-short'>
                                <p>Pattern-match the result of a parser to select which other parser to run.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.tag.html"
                                  title='macro synom::tag'>tag</a></td>
                           <td class='docblock-short'>
                                <p>Parse the given string from exactly the current position in the input. You
almost always want <code>punct!</code> or <code>keyword!</code> instead of this.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.take_until.html"
                                  title='macro synom::take_until'>take_until</a></td>
                           <td class='docblock-short'>
                                <p>Parse the part of the input up to but not including the given string. Fail
to parse if the given string is not present in the input.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.terminated.html"
                                  title='macro synom::terminated'>terminated</a></td>
                           <td class='docblock-short'>
                                <p>Parse two things, returning the value of the first.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.terminated_list.html"
                                  title='macro synom::terminated_list'>terminated_list</a></td>
                           <td class='docblock-short'>
                                <p>Zero or more values separated by some separator. A trailing separator is
allowed.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.tuple.html"
                                  title='macro synom::tuple'>tuple</a></td>
                           <td class='docblock-short'>
                                <p>Run a series of parsers and produce all of the results in a tuple.</p>

                           </td>
                       </tr>
                       <tr class=' module-item'>
                           <td><a class="macro" href="macro.value.html"
                                  title='macro synom::value'>value</a></td>
                           <td class='docblock-short'>
                                <p>Produce the given value without parsing anything. Useful as an argument to
<code>switch!</code>.</p>

                           </td>
                       </tr></table><h2 id='enums' class='section-header'><a href="#enums">Enums</a></h2>
<table>
                       <tr class=' module-item'>
                           <td><a class="enum" href="enum.IResult.html"
                                  title='enum synom::IResult'>IResult</a></td>
                           <td class='docblock-short'>
                                <p>The result of a parser.</p>

                           </td>
                       </tr></table></section>
    <section id='search' class="content hidden"></section>

    <section class="footer"></section>

    <aside id="help" class="hidden">
        <div>
            <h1 class="hidden">Help</h1>

            <div class="shortcuts">
                <h2>Keyboard Shortcuts</h2>

                <dl>
                    <dt><kbd>?</kbd></dt>
                    <dd>Show this help dialog</dd>
                    <dt><kbd>S</kbd></dt>
                    <dd>Focus the search field</dd>
                    <dt><kbd>↑</kbd></dt>
                    <dd>Move up in search results</dd>
                    <dt><kbd>↓</kbd></dt>
                    <dd>Move down in search results</dd>
                    <dt><kbd>↹</kbd></dt>
                    <dd>Switch tab</dd>
                    <dt><kbd>&#9166;</kbd></dt>
                    <dd>Go to active search result</dd>
                    <dt><kbd>+</kbd></dt>
                    <dd>Expand all sections</dd>
                    <dt><kbd>-</kbd></dt>
                    <dd>Collapse all sections</dd>
                </dl>
            </div>

            <div class="infos">
                <h2>Search Tricks</h2>

                <p>
                    Prefix searches with a type followed by a colon (e.g.
                    <code>fn:</code>) to restrict the search to a given type.
                </p>

                <p>
                    Accepted types are: <code>fn</code>, <code>mod</code>,
                    <code>struct</code>, <code>enum</code>,
                    <code>trait</code>, <code>type</code>, <code>macro</code>,
                    and <code>const</code>.
                </p>

                <p>
                    Search functions by type signature (e.g.
                    <code>vec -> usize</code> or <code>* -> vec</code>)
                </p>
            </div>
        </div>
    </aside>

    

    <script>
        window.rootPath = "../";
        window.currentCrate = "synom";
    </script>
    <script src="../main.js"></script>
    <script defer src="../search-index.js"></script>
</body>
</html>