340 lines
No EOL
25 KiB
HTML
340 lines
No EOL
25 KiB
HTML
<!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 `result` mod in crate `bitflags`.">
|
||
<meta name="keywords" content="rust, rustlang, rust-lang, result">
|
||
|
||
<title>bitflags::__core::result - Rust</title>
|
||
|
||
<link rel="stylesheet" type="text/css" href="../../../rustdoc.css">
|
||
<link rel="stylesheet" type="text/css" href="../../../main.css">
|
||
|
||
|
||
|
||
|
||
</head>
|
||
<body class="rustdoc">
|
||
<!--[if lte IE 8]>
|
||
<div class="warning">
|
||
This old browser is unsupported and will most likely display funky
|
||
things.
|
||
</div>
|
||
<![endif]-->
|
||
|
||
|
||
|
||
<nav class="sidebar">
|
||
|
||
<p class='location'><a href='../../index.html'>bitflags</a>::<wbr><a href='../index.html'>__core</a></p><script>window.sidebarCurrent = {name: 'result', ty: 'mod', relpath: '../'};</script><script defer src="../sidebar-items.js"></script>
|
||
</nav>
|
||
|
||
<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 mod">
|
||
<h1 class='fqn'><span class='in-band'>Module <a href='../../index.html'>bitflags</a>::<wbr><a href='../index.html'>__core</a>::<wbr><a class='mod' href=''>result</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'>−</span>]
|
||
</a>
|
||
</span><a id='src-30581' class='srclink' href='https://doc.rust-lang.org/nightly/core/result/index.html?gotosrc=30581' title='goto source code'>[src]</a></span></h1>
|
||
<div class='docblock'><p>Error handling with the <code>Result</code> type.</p>
|
||
|
||
<p><code>Result<T, E></code> is the type used for returning and propagating
|
||
errors. It is an enum with the variants, <code>Ok(T)</code>, representing
|
||
success and containing a value, and <code>Err(E)</code>, representing error
|
||
and containing an error value.</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>enum</span> <span class='prelude-ty'>Result</span><span class='op'><</span><span class='ident'>T</span>, <span class='ident'>E</span><span class='op'>></span> {
|
||
<span class='prelude-val'>Ok</span>(<span class='ident'>T</span>),
|
||
<span class='prelude-val'>Err</span>(<span class='ident'>E</span>),
|
||
}</pre>
|
||
|
||
<p>Functions return <code>Result</code> whenever errors are expected and
|
||
recoverable. In the <code>std</code> crate <code>Result</code> is most prominently used
|
||
for <a href="../../std/io/index.html">I/O</a>.</p>
|
||
|
||
<p>A simple function returning <code>Result</code> might be
|
||
defined and used like so:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='attribute'>#[<span class='ident'>derive</span>(<span class='ident'>Debug</span>)]</span>
|
||
<span class='kw'>enum</span> <span class='ident'>Version</span> { <span class='ident'>Version1</span>, <span class='ident'>Version2</span> }
|
||
|
||
<span class='kw'>fn</span> <span class='ident'>parse_version</span>(<span class='ident'>header</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>]) <span class='op'>-></span> <span class='prelude-ty'>Result</span><span class='op'><</span><span class='ident'>Version</span>, <span class='kw-2'>&</span><span class='lifetime'>'static</span> <span class='ident'>str</span><span class='op'>></span> {
|
||
<span class='kw'>match</span> <span class='ident'>header</span>.<span class='ident'>get</span>(<span class='number'>0</span>) {
|
||
<span class='prelude-val'>None</span> <span class='op'>=></span> <span class='prelude-val'>Err</span>(<span class='string'>"invalid header length"</span>),
|
||
<span class='prelude-val'>Some</span>(<span class='kw-2'>&</span><span class='number'>1</span>) <span class='op'>=></span> <span class='prelude-val'>Ok</span>(<span class='ident'>Version</span>::<span class='ident'>Version1</span>),
|
||
<span class='prelude-val'>Some</span>(<span class='kw-2'>&</span><span class='number'>2</span>) <span class='op'>=></span> <span class='prelude-val'>Ok</span>(<span class='ident'>Version</span>::<span class='ident'>Version2</span>),
|
||
<span class='prelude-val'>Some</span>(_) <span class='op'>=></span> <span class='prelude-val'>Err</span>(<span class='string'>"invalid version"</span>),
|
||
}
|
||
}
|
||
|
||
<span class='kw'>let</span> <span class='ident'>version</span> <span class='op'>=</span> <span class='ident'>parse_version</span>(<span class='kw-2'>&</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>]);
|
||
<span class='kw'>match</span> <span class='ident'>version</span> {
|
||
<span class='prelude-val'>Ok</span>(<span class='ident'>v</span>) <span class='op'>=></span> <span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"working with version: {:?}"</span>, <span class='ident'>v</span>),
|
||
<span class='prelude-val'>Err</span>(<span class='ident'>e</span>) <span class='op'>=></span> <span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"error parsing header: {:?}"</span>, <span class='ident'>e</span>),
|
||
}</pre>
|
||
|
||
<p>Pattern matching on <code>Result</code>s is clear and straightforward for
|
||
simple cases, but <code>Result</code> comes with some convenience methods
|
||
that make working with it more succinct.</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>good_result</span>: <span class='prelude-ty'>Result</span><span class='op'><</span><span class='ident'>i32</span>, <span class='ident'>i32</span><span class='op'>></span> <span class='op'>=</span> <span class='prelude-val'>Ok</span>(<span class='number'>10</span>);
|
||
<span class='kw'>let</span> <span class='ident'>bad_result</span>: <span class='prelude-ty'>Result</span><span class='op'><</span><span class='ident'>i32</span>, <span class='ident'>i32</span><span class='op'>></span> <span class='op'>=</span> <span class='prelude-val'>Err</span>(<span class='number'>10</span>);
|
||
|
||
<span class='comment'>// The `is_ok` and `is_err` methods do what they say.</span>
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>good_result</span>.<span class='ident'>is_ok</span>() <span class='op'>&&</span> <span class='op'>!</span><span class='ident'>good_result</span>.<span class='ident'>is_err</span>());
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>bad_result</span>.<span class='ident'>is_err</span>() <span class='op'>&&</span> <span class='op'>!</span><span class='ident'>bad_result</span>.<span class='ident'>is_ok</span>());
|
||
|
||
<span class='comment'>// `map` consumes the `Result` and produces another.</span>
|
||
<span class='kw'>let</span> <span class='ident'>good_result</span>: <span class='prelude-ty'>Result</span><span class='op'><</span><span class='ident'>i32</span>, <span class='ident'>i32</span><span class='op'>></span> <span class='op'>=</span> <span class='ident'>good_result</span>.<span class='ident'>map</span>(<span class='op'>|</span><span class='ident'>i</span><span class='op'>|</span> <span class='ident'>i</span> <span class='op'>+</span> <span class='number'>1</span>);
|
||
<span class='kw'>let</span> <span class='ident'>bad_result</span>: <span class='prelude-ty'>Result</span><span class='op'><</span><span class='ident'>i32</span>, <span class='ident'>i32</span><span class='op'>></span> <span class='op'>=</span> <span class='ident'>bad_result</span>.<span class='ident'>map</span>(<span class='op'>|</span><span class='ident'>i</span><span class='op'>|</span> <span class='ident'>i</span> <span class='op'>-</span> <span class='number'>1</span>);
|
||
|
||
<span class='comment'>// Use `and_then` to continue the computation.</span>
|
||
<span class='kw'>let</span> <span class='ident'>good_result</span>: <span class='prelude-ty'>Result</span><span class='op'><</span><span class='ident'>bool</span>, <span class='ident'>i32</span><span class='op'>></span> <span class='op'>=</span> <span class='ident'>good_result</span>.<span class='ident'>and_then</span>(<span class='op'>|</span><span class='ident'>i</span><span class='op'>|</span> <span class='prelude-val'>Ok</span>(<span class='ident'>i</span> <span class='op'>==</span> <span class='number'>11</span>));
|
||
|
||
<span class='comment'>// Use `or_else` to handle the error.</span>
|
||
<span class='kw'>let</span> <span class='ident'>bad_result</span>: <span class='prelude-ty'>Result</span><span class='op'><</span><span class='ident'>i32</span>, <span class='ident'>i32</span><span class='op'>></span> <span class='op'>=</span> <span class='ident'>bad_result</span>.<span class='ident'>or_else</span>(<span class='op'>|</span><span class='ident'>i</span><span class='op'>|</span> <span class='prelude-val'>Ok</span>(<span class='ident'>i</span> <span class='op'>+</span> <span class='number'>20</span>));
|
||
|
||
<span class='comment'>// Consume the result and return the contents with `unwrap`.</span>
|
||
<span class='kw'>let</span> <span class='ident'>final_awesome_result</span> <span class='op'>=</span> <span class='ident'>good_result</span>.<span class='ident'>unwrap</span>();</pre>
|
||
|
||
<h1 id='results-must-be-used' class='section-header'><a href='#results-must-be-used'>Results must be used</a></h1>
|
||
<p>A common problem with using return values to indicate errors is
|
||
that it is easy to ignore the return value, thus failing to handle
|
||
the error. Result is annotated with the #[must_use] attribute,
|
||
which will cause the compiler to issue a warning when a Result
|
||
value is ignored. This makes <code>Result</code> especially useful with
|
||
functions that may encounter errors but don't otherwise return a
|
||
useful value.</p>
|
||
|
||
<p>Consider the <code>write_all</code> method defined for I/O types
|
||
by the <a href="../../std/io/trait.Write.html"><code>Write</code></a> trait:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>io</span>;
|
||
|
||
<span class='kw'>trait</span> <span class='ident'>Write</span> {
|
||
<span class='kw'>fn</span> <span class='ident'>write_all</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='self'>self</span>, <span class='ident'>bytes</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>]) <span class='op'>-></span> <span class='prelude-ty'>Result</span><span class='op'><</span>(), <span class='ident'>io</span>::<span class='ident'>Error</span><span class='op'>></span>;
|
||
}</pre>
|
||
|
||
<p><em>Note: The actual definition of <code>Write</code> uses <code>io::Result</code>, which
|
||
is just a synonym for <code>Result<T, io::Error></code>.</em></p>
|
||
|
||
<p>This method doesn't produce a value, but the write may
|
||
fail. It's crucial to handle the error case, and <em>not</em> write
|
||
something like this:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>fs</span>::<span class='ident'>File</span>;
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>io</span>::<span class='ident'>prelude</span>::<span class='op'>*</span>;
|
||
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>file</span> <span class='op'>=</span> <span class='ident'>File</span>::<span class='ident'>create</span>(<span class='string'>"valuable_data.txt"</span>).<span class='ident'>unwrap</span>();
|
||
<span class='comment'>// If `write_all` errors, then we'll never know, because the return</span>
|
||
<span class='comment'>// value is ignored.</span>
|
||
<span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='string'>b"important message"</span>);</pre>
|
||
|
||
<p>If you <em>do</em> write that in Rust, the compiler will give you a
|
||
warning (by default, controlled by the <code>unused_must_use</code> lint).</p>
|
||
|
||
<p>You might instead, if you don't want to handle the error, simply
|
||
assert success with <code>expect</code>. This will panic if the
|
||
write fails, providing a marginally useful message indicating why:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>fs</span>::<span class='ident'>File</span>;
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>io</span>::<span class='ident'>prelude</span>::<span class='op'>*</span>;
|
||
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>file</span> <span class='op'>=</span> <span class='ident'>File</span>::<span class='ident'>create</span>(<span class='string'>"valuable_data.txt"</span>).<span class='ident'>unwrap</span>();
|
||
<span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='string'>b"important message"</span>).<span class='ident'>expect</span>(<span class='string'>"failed to write message"</span>);</pre>
|
||
|
||
<p>You might also simply assert success:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='string'>b"important message"</span>).<span class='ident'>is_ok</span>());</pre>
|
||
|
||
<p>Or propagate the error up the call stack with <code>try!</code>:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>fn</span> <span class='ident'>write_message</span>() <span class='op'>-></span> <span class='ident'>io</span>::<span class='prelude-ty'>Result</span><span class='op'><</span>()<span class='op'>></span> {
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>file</span> <span class='op'>=</span> <span class='macro'>try</span><span class='macro'>!</span>(<span class='ident'>File</span>::<span class='ident'>create</span>(<span class='string'>"valuable_data.txt"</span>));
|
||
<span class='macro'>try</span><span class='macro'>!</span>(<span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='string'>b"important message"</span>));
|
||
<span class='prelude-val'>Ok</span>(())
|
||
}</pre>
|
||
|
||
<h1 id='the-try-macro' class='section-header'><a href='#the-try-macro'>The <code>try!</code> macro</a></h1>
|
||
<p>When writing code that calls many functions that return the
|
||
<code>Result</code> type, the error handling can be tedious. The <code>try!</code>
|
||
macro hides some of the boilerplate of propagating errors up the
|
||
call stack.</p>
|
||
|
||
<p>It replaces this:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>fs</span>::<span class='ident'>File</span>;
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>io</span>::<span class='ident'>prelude</span>::<span class='op'>*</span>;
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>io</span>;
|
||
|
||
<span class='kw'>struct</span> <span class='ident'>Info</span> {
|
||
<span class='ident'>name</span>: <span class='ident'>String</span>,
|
||
<span class='ident'>age</span>: <span class='ident'>i32</span>,
|
||
<span class='ident'>rating</span>: <span class='ident'>i32</span>,
|
||
}
|
||
|
||
<span class='kw'>fn</span> <span class='ident'>write_info</span>(<span class='ident'>info</span>: <span class='kw-2'>&</span><span class='ident'>Info</span>) <span class='op'>-></span> <span class='ident'>io</span>::<span class='prelude-ty'>Result</span><span class='op'><</span>()<span class='op'>></span> {
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>file</span> <span class='op'>=</span> <span class='macro'>try</span><span class='macro'>!</span>(<span class='ident'>File</span>::<span class='ident'>create</span>(<span class='string'>"my_best_friends.txt"</span>));
|
||
<span class='comment'>// Early return on error</span>
|
||
<span class='kw'>if</span> <span class='kw'>let</span> <span class='prelude-val'>Err</span>(<span class='ident'>e</span>) <span class='op'>=</span> <span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='macro'>format</span><span class='macro'>!</span>(<span class='string'>"name: {}\n"</span>, <span class='ident'>info</span>.<span class='ident'>name</span>).<span class='ident'>as_bytes</span>()) {
|
||
<span class='kw'>return</span> <span class='prelude-val'>Err</span>(<span class='ident'>e</span>)
|
||
}
|
||
<span class='kw'>if</span> <span class='kw'>let</span> <span class='prelude-val'>Err</span>(<span class='ident'>e</span>) <span class='op'>=</span> <span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='macro'>format</span><span class='macro'>!</span>(<span class='string'>"age: {}\n"</span>, <span class='ident'>info</span>.<span class='ident'>age</span>).<span class='ident'>as_bytes</span>()) {
|
||
<span class='kw'>return</span> <span class='prelude-val'>Err</span>(<span class='ident'>e</span>)
|
||
}
|
||
<span class='kw'>if</span> <span class='kw'>let</span> <span class='prelude-val'>Err</span>(<span class='ident'>e</span>) <span class='op'>=</span> <span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='macro'>format</span><span class='macro'>!</span>(<span class='string'>"rating: {}\n"</span>, <span class='ident'>info</span>.<span class='ident'>rating</span>).<span class='ident'>as_bytes</span>()) {
|
||
<span class='kw'>return</span> <span class='prelude-val'>Err</span>(<span class='ident'>e</span>)
|
||
}
|
||
<span class='prelude-val'>Ok</span>(())
|
||
}</pre>
|
||
|
||
<p>With this:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>fs</span>::<span class='ident'>File</span>;
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>io</span>::<span class='ident'>prelude</span>::<span class='op'>*</span>;
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>io</span>;
|
||
|
||
<span class='kw'>struct</span> <span class='ident'>Info</span> {
|
||
<span class='ident'>name</span>: <span class='ident'>String</span>,
|
||
<span class='ident'>age</span>: <span class='ident'>i32</span>,
|
||
<span class='ident'>rating</span>: <span class='ident'>i32</span>,
|
||
}
|
||
|
||
<span class='kw'>fn</span> <span class='ident'>write_info</span>(<span class='ident'>info</span>: <span class='kw-2'>&</span><span class='ident'>Info</span>) <span class='op'>-></span> <span class='ident'>io</span>::<span class='prelude-ty'>Result</span><span class='op'><</span>()<span class='op'>></span> {
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>file</span> <span class='op'>=</span> <span class='macro'>try</span><span class='macro'>!</span>(<span class='ident'>File</span>::<span class='ident'>create</span>(<span class='string'>"my_best_friends.txt"</span>));
|
||
<span class='comment'>// Early return on error</span>
|
||
<span class='macro'>try</span><span class='macro'>!</span>(<span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='macro'>format</span><span class='macro'>!</span>(<span class='string'>"name: {}\n"</span>, <span class='ident'>info</span>.<span class='ident'>name</span>).<span class='ident'>as_bytes</span>()));
|
||
<span class='macro'>try</span><span class='macro'>!</span>(<span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='macro'>format</span><span class='macro'>!</span>(<span class='string'>"age: {}\n"</span>, <span class='ident'>info</span>.<span class='ident'>age</span>).<span class='ident'>as_bytes</span>()));
|
||
<span class='macro'>try</span><span class='macro'>!</span>(<span class='ident'>file</span>.<span class='ident'>write_all</span>(<span class='macro'>format</span><span class='macro'>!</span>(<span class='string'>"rating: {}\n"</span>, <span class='ident'>info</span>.<span class='ident'>rating</span>).<span class='ident'>as_bytes</span>()));
|
||
<span class='prelude-val'>Ok</span>(())
|
||
}</pre>
|
||
|
||
<p><em>It's much nicer!</em></p>
|
||
|
||
<p>Wrapping an expression in <code>try!</code> will result in the unwrapped
|
||
success (<code>Ok</code>) value, unless the result is <code>Err</code>, in which case
|
||
<code>Err</code> is returned early from the enclosing function. Its simple definition
|
||
makes it clear:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>try</span> {
|
||
(<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>e</span>:<span class='ident'>expr</span>) <span class='op'>=></span> (<span class='kw'>match</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>e</span> { <span class='prelude-val'>Ok</span>(<span class='ident'>e</span>) <span class='op'>=></span> <span class='ident'>e</span>, <span class='prelude-val'>Err</span>(<span class='ident'>e</span>) <span class='op'>=></span> <span class='kw'>return</span> <span class='prelude-val'>Err</span>(<span class='ident'>e</span>) })
|
||
}</pre>
|
||
|
||
<p><code>try!</code> is imported by the prelude and is available everywhere, but it can only
|
||
be used in functions that return <code>Result</code> because of the early return of
|
||
<code>Err</code> that it provides.</p>
|
||
</div><h2 id='structs' class='section-header'><a href="#structs">Structs</a></h2>
|
||
<table>
|
||
<tr class=' module-item'>
|
||
<td><a class='struct' href='struct.IntoIter.html'
|
||
title='bitflags::__core::result::IntoIter'>IntoIter</a></td>
|
||
<td class='docblock short'>
|
||
<p>An iterator over the value in a <code>Ok</code> variant of a <code>Result</code>.</p>
|
||
</td>
|
||
</tr>
|
||
<tr class=' module-item'>
|
||
<td><a class='struct' href='struct.Iter.html'
|
||
title='bitflags::__core::result::Iter'>Iter</a></td>
|
||
<td class='docblock short'>
|
||
<p>An iterator over a reference to the <code>Ok</code> variant of a <code>Result</code>.</p>
|
||
</td>
|
||
</tr>
|
||
<tr class=' module-item'>
|
||
<td><a class='struct' href='struct.IterMut.html'
|
||
title='bitflags::__core::result::IterMut'>IterMut</a></td>
|
||
<td class='docblock short'>
|
||
<p>An iterator over a mutable reference to the <code>Ok</code> variant of a <code>Result</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.Result.html'
|
||
title='bitflags::__core::result::Result'>Result</a></td>
|
||
<td class='docblock short'>
|
||
<p><code>Result</code> is a type that represents either success (<code>Ok</code>) or failure (<code>Err</code>).</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>?</dt>
|
||
<dd>Show this help dialog</dd>
|
||
<dt>S</dt>
|
||
<dd>Focus the search field</dd>
|
||
<dt>⇤</dt>
|
||
<dd>Move up in search results</dd>
|
||
<dt>⇥</dt>
|
||
<dd>Move down in search results</dd>
|
||
<dt>⏎</dt>
|
||
<dd>Go to active search result</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 = "bitflags";
|
||
window.playgroundUrl = "";
|
||
</script>
|
||
<script src="../../../jquery.js"></script>
|
||
<script src="../../../main.js"></script>
|
||
|
||
<script defer src="../../../search-index.js"></script>
|
||
</body>
|
||
</html> |