Sophie

Sophie

distrib > Mageia > 6 > armv7hl > media > core-updates > by-pkgid > 564935689ab5527f955e5449ded02799 > files > 2867

rust-doc-1.19.0-1.mga6.armv7hl.rpm

<!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 `AsciiExt` trait in crate `std`.">
    <meta name="keywords" content="rust, rustlang, rust-lang, AsciiExt">

    <title>std::ascii::AsciiExt - Rust</title>

    <link rel="stylesheet" type="text/css" href="../../normalize.css">
    <link rel="stylesheet" type="text/css" href="../../rustdoc.css">
    <link rel="stylesheet" type="text/css" href="../../main.css">
    

    <link rel="shortcut icon" href="https://doc.rust-lang.org/favicon.ico">
    
</head>
<body class="rustdoc trait">
    <!--[if lte IE 8]>
    <div class="warning">
        This old browser is unsupported and will most likely display funky
        things.
    </div>
    <![endif]-->

    

    <nav class="sidebar">
        <a href='../../std/index.html'><img src='https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png' alt='logo' width='100'></a>
        <p class='location'>Trait AsciiExt</p><div class="block items"><ul><li><a href="#associated-types">Associated Types</a></li><li><a href="#required-methods">Required Methods</a></li><li><a href="#provided-methods">Provided Methods</a></li><li><a href="#implementors">Implementors</a></li></ul></div><p class='location'><a href='../index.html'>std</a>::<wbr><a href='index.html'>ascii</a></p><script>window.sidebarCurrent = {name: 'AsciiExt', ty: 'trait', 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">
<h1 class='fqn'><span class='in-band'>Trait <a href='../index.html'>std</a>::<wbr><a href='index.html'>ascii</a>::<wbr><a class="trait" href=''>AsciiExt</a></span><span class='out-of-band'><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><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/std/ascii.rs.html#56-568' title='goto source code'>[src]</a></span></h1>
<pre class='rust trait'>pub trait AsciiExt {
    type <a href='#associatedtype.Owned' class="type">Owned</a>;
    fn <a href='#tymethod.is_ascii' class='fnname'>is_ascii</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a>;
    fn <a href='#tymethod.to_ascii_uppercase' class='fnname'>to_ascii_uppercase</a>(&amp;self) -&gt; Self::<a class="trait" href="../../std/ascii/trait.AsciiExt.html" title="trait std::ascii::AsciiExt">Owned</a>;
    fn <a href='#tymethod.to_ascii_lowercase' class='fnname'>to_ascii_lowercase</a>(&amp;self) -&gt; Self::<a class="trait" href="../../std/ascii/trait.AsciiExt.html" title="trait std::ascii::AsciiExt">Owned</a>;
    fn <a href='#tymethod.eq_ignore_ascii_case' class='fnname'>eq_ignore_ascii_case</a>(&amp;self, other: &amp;Self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a>;
    fn <a href='#tymethod.make_ascii_uppercase' class='fnname'>make_ascii_uppercase</a>(&amp;mut self);
    fn <a href='#tymethod.make_ascii_lowercase' class='fnname'>make_ascii_lowercase</a>(&amp;mut self);

    fn <a href='#method.is_ascii_alphabetic' class='fnname'>is_ascii_alphabetic</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_uppercase' class='fnname'>is_ascii_uppercase</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_lowercase' class='fnname'>is_ascii_lowercase</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_alphanumeric' class='fnname'>is_ascii_alphanumeric</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_digit' class='fnname'>is_ascii_digit</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_hexdigit' class='fnname'>is_ascii_hexdigit</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_punctuation' class='fnname'>is_ascii_punctuation</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_graphic' class='fnname'>is_ascii_graphic</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_whitespace' class='fnname'>is_ascii_whitespace</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
    fn <a href='#method.is_ascii_control' class='fnname'>is_ascii_control</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a> { ... }
}</pre><div class='docblock'><p>Extension methods for ASCII-subset only operations.</p>

<p>Be aware that operations on seemingly non-ASCII characters can sometimes
have unexpected results. Consider this example:</p>

<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;

<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">&quot;café&quot;</span>.<span class="ident">to_ascii_uppercase</span>(), <span class="string">&quot;CAFÉ&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">&quot;café&quot;</span>.<span class="ident">to_ascii_uppercase</span>(), <span class="string">&quot;CAFé&quot;</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0A%0Aassert_eq!(%22cafe%CC%81%22.to_ascii_uppercase()%2C%20%22CAFE%CC%81%22)%3B%0Aassert_eq!(%22caf%C3%A9%22.to_ascii_uppercase()%2C%20%22CAF%C3%A9%22)%3B%0A%7D">Run</a></pre>

<p>In the first example, the lowercased string is represented <code>&quot;cafe\u{301}&quot;</code>
(the last character is an acute accent <a href="https://en.wikipedia.org/wiki/Combining_character">combining character</a>). Unlike the
other characters in the string, the combining character will not get mapped
to an uppercase variant, resulting in <code>&quot;CAFE\u{301}&quot;</code>. In the second
example, the lowercased string is represented <code>&quot;caf\u{e9}&quot;</code> (the last
character is a single Unicode character representing an &#39;e&#39; with an acute
accent). Since the last character is defined outside the scope of ASCII,
it will not get mapped to an uppercase variant, resulting in <code>&quot;CAF\u{e9}&quot;</code>.</p>
</div>
            <h2 id='associated-types'>Associated Types</h2>
            <div class='methods'>
        <h3 id='associatedtype.Owned' class='method'><span id='Owned.t' class='invisible'><code>type <a href='#associatedtype.Owned' class="type">Owned</a></code></span></h3><div class='docblock'><p>Container type for copied ASCII characters.</p>
</div></div>
            <h2 id='required-methods'>Required Methods</h2>
            <div class='methods'>
        <h3 id='tymethod.is_ascii' class='method'><span id='is_ascii.v' class='invisible'><code>fn <a href='#tymethod.is_ascii' class='fnname'>is_ascii</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='docblock'><p>Checks if the value is within the ASCII range.</p>

<h1 id='examples' class='section-header'><a href='#examples'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;

<span class="kw">let</span> <span class="ident">ascii</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">non_ascii</span> <span class="op">=</span> <span class="string">&#39;❤&#39;</span>;
<span class="kw">let</span> <span class="ident">int_ascii</span> <span class="op">=</span> <span class="number">97</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">ascii</span>.<span class="ident">is_ascii</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">non_ascii</span>.<span class="ident">is_ascii</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">int_ascii</span>.<span class="ident">is_ascii</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0A%0Alet%20ascii%20%3D%20'a'%3B%0Alet%20non_ascii%20%3D%20'%E2%9D%A4'%3B%0Alet%20int_ascii%20%3D%2097%3B%0A%0Aassert!(ascii.is_ascii())%3B%0Aassert!(!non_ascii.is_ascii())%3B%0Aassert!(int_ascii.is_ascii())%3B%0A%7D">Run</a></pre>
</div><h3 id='tymethod.to_ascii_uppercase' class='method'><span id='to_ascii_uppercase.v' class='invisible'><code>fn <a href='#tymethod.to_ascii_uppercase' class='fnname'>to_ascii_uppercase</a>(&amp;self) -&gt; Self::<a class="trait" href="../../std/ascii/trait.AsciiExt.html" title="trait std::ascii::AsciiExt">Owned</a></code></span></h3><div class='docblock'><p>Makes a copy of the value in its ASCII upper case equivalent.</p>

<p>ASCII letters &#39;a&#39; to &#39;z&#39; are mapped to &#39;A&#39; to &#39;Z&#39;,
but non-ASCII letters are unchanged.</p>

<p>To uppercase the value in-place, use <a href="#tymethod.make_ascii_uppercase"><code>make_ascii_uppercase</code></a>.</p>

<p>To uppercase ASCII characters in addition to non-ASCII characters, use
<a href="../primitive.str.html#method.to_uppercase"><code>str::to_uppercase</code></a>.</p>

<h1 id='examples-1' class='section-header'><a href='#examples-1'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;

<span class="kw">let</span> <span class="ident">ascii</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">non_ascii</span> <span class="op">=</span> <span class="string">&#39;❤&#39;</span>;
<span class="kw">let</span> <span class="ident">int_ascii</span> <span class="op">=</span> <span class="number">97</span>;

<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">&#39;A&#39;</span>, <span class="ident">ascii</span>.<span class="ident">to_ascii_uppercase</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">&#39;❤&#39;</span>, <span class="ident">non_ascii</span>.<span class="ident">to_ascii_uppercase</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">65</span>, <span class="ident">int_ascii</span>.<span class="ident">to_ascii_uppercase</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0A%0Alet%20ascii%20%3D%20'a'%3B%0Alet%20non_ascii%20%3D%20'%E2%9D%A4'%3B%0Alet%20int_ascii%20%3D%2097%3B%0A%0Aassert_eq!('A'%2C%20ascii.to_ascii_uppercase())%3B%0Aassert_eq!('%E2%9D%A4'%2C%20non_ascii.to_ascii_uppercase())%3B%0Aassert_eq!(65%2C%20int_ascii.to_ascii_uppercase())%3B%0A%7D">Run</a></pre>
</div><h3 id='tymethod.to_ascii_lowercase' class='method'><span id='to_ascii_lowercase.v' class='invisible'><code>fn <a href='#tymethod.to_ascii_lowercase' class='fnname'>to_ascii_lowercase</a>(&amp;self) -&gt; Self::<a class="trait" href="../../std/ascii/trait.AsciiExt.html" title="trait std::ascii::AsciiExt">Owned</a></code></span></h3><div class='docblock'><p>Makes a copy of the value in its ASCII lower case equivalent.</p>

<p>ASCII letters &#39;A&#39; to &#39;Z&#39; are mapped to &#39;a&#39; to &#39;z&#39;,
but non-ASCII letters are unchanged.</p>

<p>To lowercase the value in-place, use <a href="#tymethod.make_ascii_lowercase"><code>make_ascii_lowercase</code></a>.</p>

<p>To lowercase ASCII characters in addition to non-ASCII characters, use
<a href="../primitive.str.html#method.to_lowercase"><code>str::to_lowercase</code></a>.</p>

<h1 id='examples-2' class='section-header'><a href='#examples-2'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;

<span class="kw">let</span> <span class="ident">ascii</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">non_ascii</span> <span class="op">=</span> <span class="string">&#39;❤&#39;</span>;
<span class="kw">let</span> <span class="ident">int_ascii</span> <span class="op">=</span> <span class="number">65</span>;

<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">&#39;a&#39;</span>, <span class="ident">ascii</span>.<span class="ident">to_ascii_lowercase</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">&#39;❤&#39;</span>, <span class="ident">non_ascii</span>.<span class="ident">to_ascii_lowercase</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">97</span>, <span class="ident">int_ascii</span>.<span class="ident">to_ascii_lowercase</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0A%0Alet%20ascii%20%3D%20'A'%3B%0Alet%20non_ascii%20%3D%20'%E2%9D%A4'%3B%0Alet%20int_ascii%20%3D%2065%3B%0A%0Aassert_eq!('a'%2C%20ascii.to_ascii_lowercase())%3B%0Aassert_eq!('%E2%9D%A4'%2C%20non_ascii.to_ascii_lowercase())%3B%0Aassert_eq!(97%2C%20int_ascii.to_ascii_lowercase())%3B%0A%7D">Run</a></pre>
</div><h3 id='tymethod.eq_ignore_ascii_case' class='method'><span id='eq_ignore_ascii_case.v' class='invisible'><code>fn <a href='#tymethod.eq_ignore_ascii_case' class='fnname'>eq_ignore_ascii_case</a>(&amp;self, other: &amp;Self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='docblock'><p>Checks that two values are an ASCII case-insensitive match.</p>

<p>Same as <code>to_ascii_lowercase(a) == to_ascii_lowercase(b)</code>,
but without allocating and copying temporaries.</p>

<h1 id='examples-3' class='section-header'><a href='#examples-3'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;

<span class="kw">let</span> <span class="ident">ascii1</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">ascii2</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">ascii3</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">ascii4</span> <span class="op">=</span> <span class="string">&#39;z&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">ascii1</span>.<span class="ident">eq_ignore_ascii_case</span>(<span class="kw-2">&amp;</span><span class="ident">ascii2</span>));
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">ascii1</span>.<span class="ident">eq_ignore_ascii_case</span>(<span class="kw-2">&amp;</span><span class="ident">ascii3</span>));
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">ascii1</span>.<span class="ident">eq_ignore_ascii_case</span>(<span class="kw-2">&amp;</span><span class="ident">ascii4</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0A%0Alet%20ascii1%20%3D%20'A'%3B%0Alet%20ascii2%20%3D%20'a'%3B%0Alet%20ascii3%20%3D%20'A'%3B%0Alet%20ascii4%20%3D%20'z'%3B%0A%0Aassert!(ascii1.eq_ignore_ascii_case(%26ascii2))%3B%0Aassert!(ascii1.eq_ignore_ascii_case(%26ascii3))%3B%0Aassert!(!ascii1.eq_ignore_ascii_case(%26ascii4))%3B%0A%7D">Run</a></pre>
</div><h3 id='tymethod.make_ascii_uppercase' class='method'><span id='make_ascii_uppercase.v' class='invisible'><code>fn <a href='#tymethod.make_ascii_uppercase' class='fnname'>make_ascii_uppercase</a>(&amp;mut self)</code><div class='since' title='Stable since Rust version 1.9.0'>1.9.0</div></span></h3><div class='docblock'><p>Converts this type to its ASCII upper case equivalent in-place.</p>

<p>ASCII letters &#39;a&#39; to &#39;z&#39; are mapped to &#39;A&#39; to &#39;Z&#39;,
but non-ASCII letters are unchanged.</p>

<p>To return a new uppercased value without modifying the existing one, use
<a href="#tymethod.to_ascii_uppercase"><code>to_ascii_uppercase</code></a>.</p>

<h1 id='examples-4' class='section-header'><a href='#examples-4'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;

<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">ascii</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;

<span class="ident">ascii</span>.<span class="ident">make_ascii_uppercase</span>();

<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">&#39;A&#39;</span>, <span class="ident">ascii</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0A%0Alet%20mut%20ascii%20%3D%20'a'%3B%0A%0Aascii.make_ascii_uppercase()%3B%0A%0Aassert_eq!('A'%2C%20ascii)%3B%0A%7D">Run</a></pre>
</div><h3 id='tymethod.make_ascii_lowercase' class='method'><span id='make_ascii_lowercase.v' class='invisible'><code>fn <a href='#tymethod.make_ascii_lowercase' class='fnname'>make_ascii_lowercase</a>(&amp;mut self)</code><div class='since' title='Stable since Rust version 1.9.0'>1.9.0</div></span></h3><div class='docblock'><p>Converts this type to its ASCII lower case equivalent in-place.</p>

<p>ASCII letters &#39;A&#39; to &#39;Z&#39; are mapped to &#39;a&#39; to &#39;z&#39;,
but non-ASCII letters are unchanged.</p>

<p>To return a new lowercased value without modifying the existing one, use
<a href="#tymethod.to_ascii_lowercase"><code>to_ascii_lowercase</code></a>.</p>

<h1 id='examples-5' class='section-header'><a href='#examples-5'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;

<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">ascii</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;

<span class="ident">ascii</span>.<span class="ident">make_ascii_lowercase</span>();

<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="string">&#39;a&#39;</span>, <span class="ident">ascii</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0A%0Alet%20mut%20ascii%20%3D%20'A'%3B%0A%0Aascii.make_ascii_lowercase()%3B%0A%0Aassert_eq!('a'%2C%20ascii)%3B%0A%7D">Run</a></pre>
</div></div>
            <h2 id='provided-methods'>Provided Methods</h2>
            <div class='methods'>
        <h3 id='method.is_ascii_alphabetic' class='method'><span id='is_ascii_alphabetic.v' class='invisible'><code>fn <a href='#method.is_ascii_alphabetic' class='fnname'>is_ascii_alphabetic</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII alphabetic character:
U+0041 &#39;A&#39; ... U+005A &#39;Z&#39; or U+0061 &#39;a&#39; ... U+007A &#39;z&#39;.
For strings, true if all characters in the string are
ASCII alphabetic.</p>

<h1 id='examples-6' class='section-header'><a href='#examples-6'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">A</span>.<span class="ident">is_ascii_alphabetic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">G</span>.<span class="ident">is_ascii_alphabetic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">is_ascii_alphabetic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">g</span>.<span class="ident">is_ascii_alphabetic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">zero</span>.<span class="ident">is_ascii_alphabetic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">percent</span>.<span class="ident">is_ascii_alphabetic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_alphabetic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">lf</span>.<span class="ident">is_ascii_alphabetic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_alphabetic</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(A.is_ascii_alphabetic())%3B%0Aassert!(G.is_ascii_alphabetic())%3B%0Aassert!(a.is_ascii_alphabetic())%3B%0Aassert!(g.is_ascii_alphabetic())%3B%0Aassert!(!zero.is_ascii_alphabetic())%3B%0Aassert!(!percent.is_ascii_alphabetic())%3B%0Aassert!(!space.is_ascii_alphabetic())%3B%0Aassert!(!lf.is_ascii_alphabetic())%3B%0Aassert!(!esc.is_ascii_alphabetic())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_uppercase' class='method'><span id='is_ascii_uppercase.v' class='invisible'><code>fn <a href='#method.is_ascii_uppercase' class='fnname'>is_ascii_uppercase</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII uppercase character:
U+0041 &#39;A&#39; ... U+005A &#39;Z&#39;.
For strings, true if all characters in the string are
ASCII uppercase.</p>

<h1 id='examples-7' class='section-header'><a href='#examples-7'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">A</span>.<span class="ident">is_ascii_uppercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">G</span>.<span class="ident">is_ascii_uppercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">a</span>.<span class="ident">is_ascii_uppercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">g</span>.<span class="ident">is_ascii_uppercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">zero</span>.<span class="ident">is_ascii_uppercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">percent</span>.<span class="ident">is_ascii_uppercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_uppercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">lf</span>.<span class="ident">is_ascii_uppercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_uppercase</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(A.is_ascii_uppercase())%3B%0Aassert!(G.is_ascii_uppercase())%3B%0Aassert!(!a.is_ascii_uppercase())%3B%0Aassert!(!g.is_ascii_uppercase())%3B%0Aassert!(!zero.is_ascii_uppercase())%3B%0Aassert!(!percent.is_ascii_uppercase())%3B%0Aassert!(!space.is_ascii_uppercase())%3B%0Aassert!(!lf.is_ascii_uppercase())%3B%0Aassert!(!esc.is_ascii_uppercase())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_lowercase' class='method'><span id='is_ascii_lowercase.v' class='invisible'><code>fn <a href='#method.is_ascii_lowercase' class='fnname'>is_ascii_lowercase</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII lowercase character:
U+0061 &#39;a&#39; ... U+007A &#39;z&#39;.
For strings, true if all characters in the string are
ASCII lowercase.</p>

<h1 id='examples-8' class='section-header'><a href='#examples-8'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">A</span>.<span class="ident">is_ascii_lowercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">G</span>.<span class="ident">is_ascii_lowercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">is_ascii_lowercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">g</span>.<span class="ident">is_ascii_lowercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">zero</span>.<span class="ident">is_ascii_lowercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">percent</span>.<span class="ident">is_ascii_lowercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_lowercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">lf</span>.<span class="ident">is_ascii_lowercase</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_lowercase</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(!A.is_ascii_lowercase())%3B%0Aassert!(!G.is_ascii_lowercase())%3B%0Aassert!(a.is_ascii_lowercase())%3B%0Aassert!(g.is_ascii_lowercase())%3B%0Aassert!(!zero.is_ascii_lowercase())%3B%0Aassert!(!percent.is_ascii_lowercase())%3B%0Aassert!(!space.is_ascii_lowercase())%3B%0Aassert!(!lf.is_ascii_lowercase())%3B%0Aassert!(!esc.is_ascii_lowercase())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_alphanumeric' class='method'><span id='is_ascii_alphanumeric.v' class='invisible'><code>fn <a href='#method.is_ascii_alphanumeric' class='fnname'>is_ascii_alphanumeric</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII alphanumeric character:
U+0041 &#39;A&#39; ... U+005A &#39;Z&#39;, U+0061 &#39;a&#39; ... U+007A &#39;z&#39;, or
U+0030 &#39;0&#39; ... U+0039 &#39;9&#39;.
For strings, true if all characters in the string are
ASCII alphanumeric.</p>

<h1 id='examples-9' class='section-header'><a href='#examples-9'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">A</span>.<span class="ident">is_ascii_alphanumeric</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">G</span>.<span class="ident">is_ascii_alphanumeric</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">is_ascii_alphanumeric</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">g</span>.<span class="ident">is_ascii_alphanumeric</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">zero</span>.<span class="ident">is_ascii_alphanumeric</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">percent</span>.<span class="ident">is_ascii_alphanumeric</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_alphanumeric</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">lf</span>.<span class="ident">is_ascii_alphanumeric</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_alphanumeric</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(A.is_ascii_alphanumeric())%3B%0Aassert!(G.is_ascii_alphanumeric())%3B%0Aassert!(a.is_ascii_alphanumeric())%3B%0Aassert!(g.is_ascii_alphanumeric())%3B%0Aassert!(zero.is_ascii_alphanumeric())%3B%0Aassert!(!percent.is_ascii_alphanumeric())%3B%0Aassert!(!space.is_ascii_alphanumeric())%3B%0Aassert!(!lf.is_ascii_alphanumeric())%3B%0Aassert!(!esc.is_ascii_alphanumeric())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_digit' class='method'><span id='is_ascii_digit.v' class='invisible'><code>fn <a href='#method.is_ascii_digit' class='fnname'>is_ascii_digit</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII decimal digit:
U+0030 &#39;0&#39; ... U+0039 &#39;9&#39;.
For strings, true if all characters in the string are
ASCII digits.</p>

<h1 id='examples-10' class='section-header'><a href='#examples-10'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">A</span>.<span class="ident">is_ascii_digit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">G</span>.<span class="ident">is_ascii_digit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">a</span>.<span class="ident">is_ascii_digit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">g</span>.<span class="ident">is_ascii_digit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">zero</span>.<span class="ident">is_ascii_digit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">percent</span>.<span class="ident">is_ascii_digit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_digit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">lf</span>.<span class="ident">is_ascii_digit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_digit</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(!A.is_ascii_digit())%3B%0Aassert!(!G.is_ascii_digit())%3B%0Aassert!(!a.is_ascii_digit())%3B%0Aassert!(!g.is_ascii_digit())%3B%0Aassert!(zero.is_ascii_digit())%3B%0Aassert!(!percent.is_ascii_digit())%3B%0Aassert!(!space.is_ascii_digit())%3B%0Aassert!(!lf.is_ascii_digit())%3B%0Aassert!(!esc.is_ascii_digit())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_hexdigit' class='method'><span id='is_ascii_hexdigit.v' class='invisible'><code>fn <a href='#method.is_ascii_hexdigit' class='fnname'>is_ascii_hexdigit</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII hexadecimal digit:
U+0030 &#39;0&#39; ... U+0039 &#39;9&#39;, U+0041 &#39;A&#39; ... U+0046 &#39;F&#39;, or
U+0061 &#39;a&#39; ... U+0066 &#39;f&#39;.
For strings, true if all characters in the string are
ASCII hex digits.</p>

<h1 id='examples-11' class='section-header'><a href='#examples-11'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">A</span>.<span class="ident">is_ascii_hexdigit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">G</span>.<span class="ident">is_ascii_hexdigit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">is_ascii_hexdigit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">g</span>.<span class="ident">is_ascii_hexdigit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">zero</span>.<span class="ident">is_ascii_hexdigit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">percent</span>.<span class="ident">is_ascii_hexdigit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_hexdigit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">lf</span>.<span class="ident">is_ascii_hexdigit</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_hexdigit</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(A.is_ascii_hexdigit())%3B%0Aassert!(!G.is_ascii_hexdigit())%3B%0Aassert!(a.is_ascii_hexdigit())%3B%0Aassert!(!g.is_ascii_hexdigit())%3B%0Aassert!(zero.is_ascii_hexdigit())%3B%0Aassert!(!percent.is_ascii_hexdigit())%3B%0Aassert!(!space.is_ascii_hexdigit())%3B%0Aassert!(!lf.is_ascii_hexdigit())%3B%0Aassert!(!esc.is_ascii_hexdigit())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_punctuation' class='method'><span id='is_ascii_punctuation.v' class='invisible'><code>fn <a href='#method.is_ascii_punctuation' class='fnname'>is_ascii_punctuation</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII punctuation character:
U+0021 ... U+002F <code>! &quot; # $ % &amp; &#39; ( ) * + , - . /</code>
U+003A ... U+0040 <code>: ; &lt; = &gt; ? @</code>
U+005B ... U+0060 <code>[ \\ ] ^ _ \</code><code>U+007B ... U+007E</code>{ | } ~`
For strings, true if all characters in the string are
ASCII punctuation.</p>

<h1 id='examples-12' class='section-header'><a href='#examples-12'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">A</span>.<span class="ident">is_ascii_punctuation</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">G</span>.<span class="ident">is_ascii_punctuation</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">a</span>.<span class="ident">is_ascii_punctuation</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">g</span>.<span class="ident">is_ascii_punctuation</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">zero</span>.<span class="ident">is_ascii_punctuation</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">percent</span>.<span class="ident">is_ascii_punctuation</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_punctuation</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">lf</span>.<span class="ident">is_ascii_punctuation</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_punctuation</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(!A.is_ascii_punctuation())%3B%0Aassert!(!G.is_ascii_punctuation())%3B%0Aassert!(!a.is_ascii_punctuation())%3B%0Aassert!(!g.is_ascii_punctuation())%3B%0Aassert!(!zero.is_ascii_punctuation())%3B%0Aassert!(percent.is_ascii_punctuation())%3B%0Aassert!(!space.is_ascii_punctuation())%3B%0Aassert!(!lf.is_ascii_punctuation())%3B%0Aassert!(!esc.is_ascii_punctuation())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_graphic' class='method'><span id='is_ascii_graphic.v' class='invisible'><code>fn <a href='#method.is_ascii_graphic' class='fnname'>is_ascii_graphic</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII graphic character:
U+0021 &#39;@&#39; ... U+007E &#39;~&#39;.
For strings, true if all characters in the string are
ASCII punctuation.</p>

<h1 id='examples-13' class='section-header'><a href='#examples-13'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">A</span>.<span class="ident">is_ascii_graphic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">G</span>.<span class="ident">is_ascii_graphic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">is_ascii_graphic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">g</span>.<span class="ident">is_ascii_graphic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">zero</span>.<span class="ident">is_ascii_graphic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">percent</span>.<span class="ident">is_ascii_graphic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_graphic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">lf</span>.<span class="ident">is_ascii_graphic</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_graphic</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(A.is_ascii_graphic())%3B%0Aassert!(G.is_ascii_graphic())%3B%0Aassert!(a.is_ascii_graphic())%3B%0Aassert!(g.is_ascii_graphic())%3B%0Aassert!(zero.is_ascii_graphic())%3B%0Aassert!(percent.is_ascii_graphic())%3B%0Aassert!(!space.is_ascii_graphic())%3B%0Aassert!(!lf.is_ascii_graphic())%3B%0Aassert!(!esc.is_ascii_graphic())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_whitespace' class='method'><span id='is_ascii_whitespace.v' class='invisible'><code>fn <a href='#method.is_ascii_whitespace' class='fnname'>is_ascii_whitespace</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII whitespace character:
U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
U+000C FORM FEED, or U+000D CARRIAGE RETURN.
For strings, true if all characters in the string are
ASCII whitespace.</p>

<p>Rust uses the WhatWG Infra Standard&#39;s <a href="https://infra.spec.whatwg.org/#ascii-whitespace">definition of ASCII
whitespace</a>.  There are several other definitions in
wide use.  For instance, <a href="http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01">the POSIX locale</a> includes
U+000B VERTICAL TAB as well as all the above characters,
but—from the very same specification—<a href="http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05">the default rule for
&quot;field splitting&quot; in the Bourne shell</a> considers <em>only</em>
SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.</p>

<p>If you are writing a program that will process an existing
file format, check what that format&#39;s definition of whitespace is
before using this function.</p>

<h1 id='examples-14' class='section-header'><a href='#examples-14'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">A</span>.<span class="ident">is_ascii_whitespace</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">G</span>.<span class="ident">is_ascii_whitespace</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">a</span>.<span class="ident">is_ascii_whitespace</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">g</span>.<span class="ident">is_ascii_whitespace</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">zero</span>.<span class="ident">is_ascii_whitespace</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">percent</span>.<span class="ident">is_ascii_whitespace</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">space</span>.<span class="ident">is_ascii_whitespace</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">lf</span>.<span class="ident">is_ascii_whitespace</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">esc</span>.<span class="ident">is_ascii_whitespace</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(!A.is_ascii_whitespace())%3B%0Aassert!(!G.is_ascii_whitespace())%3B%0Aassert!(!a.is_ascii_whitespace())%3B%0Aassert!(!g.is_ascii_whitespace())%3B%0Aassert!(!zero.is_ascii_whitespace())%3B%0Aassert!(!percent.is_ascii_whitespace())%3B%0Aassert!(space.is_ascii_whitespace())%3B%0Aassert!(lf.is_ascii_whitespace())%3B%0Aassert!(!esc.is_ascii_whitespace())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div><h3 id='method.is_ascii_control' class='method'><span id='is_ascii_control.v' class='invisible'><code>fn <a href='#method.is_ascii_control' class='fnname'>is_ascii_control</a>(&amp;self) -&gt; <a class="primitive" href="../primitive.bool.html">bool</a></code></span></h3><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API.  (<code>ascii_ctype </code><a href="https://github.com/rust-lang/rust/issues/39658">#39658</a>)</div></div><div class='docblock'><p>Checks if the value is an ASCII control character:
U+0000 NUL ... U+001F UNIT SEPARATOR, or U+007F DELETE.
Note that most ASCII whitespace characters are control
characters, but SPACE is not.</p>

<h1 id='examples-15' class='section-header'><a href='#examples-15'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#<span class="op">!</span>[<span class="ident">feature</span>(<span class="ident">ascii_ctype</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ascii</span>::<span class="ident">AsciiExt</span>;
<span class="kw">let</span> <span class="ident">A</span> <span class="op">=</span> <span class="string">&#39;A&#39;</span>;
<span class="kw">let</span> <span class="ident">G</span> <span class="op">=</span> <span class="string">&#39;G&#39;</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="string">&#39;a&#39;</span>;
<span class="kw">let</span> <span class="ident">g</span> <span class="op">=</span> <span class="string">&#39;g&#39;</span>;
<span class="kw">let</span> <span class="ident">zero</span> <span class="op">=</span> <span class="string">&#39;0&#39;</span>;
<span class="kw">let</span> <span class="ident">percent</span> <span class="op">=</span> <span class="string">&#39;%&#39;</span>;
<span class="kw">let</span> <span class="ident">space</span> <span class="op">=</span> <span class="string">&#39; &#39;</span>;
<span class="kw">let</span> <span class="ident">lf</span> <span class="op">=</span> <span class="string">&#39;\n&#39;</span>;
<span class="kw">let</span> <span class="ident">esc</span> <span class="op">=</span> <span class="string">&#39;\u{001b}&#39;</span>;

<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">A</span>.<span class="ident">is_ascii_control</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">G</span>.<span class="ident">is_ascii_control</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">a</span>.<span class="ident">is_ascii_control</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">g</span>.<span class="ident">is_ascii_control</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">zero</span>.<span class="ident">is_ascii_control</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">percent</span>.<span class="ident">is_ascii_control</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">space</span>.<span class="ident">is_ascii_control</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">lf</span>.<span class="ident">is_ascii_control</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">esc</span>.<span class="ident">is_ascii_control</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Bfeature(ascii_ctype)%5D%0A%23!%5Ballow(non_snake_case)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aascii%3A%3AAsciiExt%3B%0Alet%20A%20%3D%20'A'%3B%0Alet%20G%20%3D%20'G'%3B%0Alet%20a%20%3D%20'a'%3B%0Alet%20g%20%3D%20'g'%3B%0Alet%20zero%20%3D%20'0'%3B%0Alet%20percent%20%3D%20'%25'%3B%0Alet%20space%20%3D%20'%20'%3B%0Alet%20lf%20%3D%20'%5Cn'%3B%0Alet%20esc%20%3D%20'%5Cu%7B001b%7D'%3B%0A%0Aassert!(!A.is_ascii_control())%3B%0Aassert!(!G.is_ascii_control())%3B%0Aassert!(!a.is_ascii_control())%3B%0Aassert!(!g.is_ascii_control())%3B%0Aassert!(!zero.is_ascii_control())%3B%0Aassert!(!percent.is_ascii_control())%3B%0Aassert!(!space.is_ascii_control())%3B%0Aassert!(lf.is_ascii_control())%3B%0Aassert!(esc.is_ascii_control())%3B%0A%7D&amp;version=nightly">Run</a></pre>
</div></div>
        <h2 id='implementors'>Implementors</h2>
        <ul class='item-list' id='implementors-list'>
    <li><code>impl AsciiExt for <a class="primitive" href="../primitive.str.html">str</a></code></li>
<li><code>impl AsciiExt for <a class="primitive" href="../primitive.slice.html">[</a><a class="primitive" href="../primitive.u8.html">u8</a><a class="primitive" href="../primitive.slice.html">]</a></code></li>
<li><code>impl AsciiExt for <a class="primitive" href="../primitive.u8.html">u8</a></code></li>
<li><code>impl AsciiExt for <a class="primitive" href="../primitive.char.html">char</a></code></li>
</ul><script type="text/javascript" async
                         src="../../implementors/std/ascii/trait.AsciiExt.js">
                 </script></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>&larrb;</dt>
                    <dd>Move up in search results</dd>
                    <dt>&rarrb;</dt>
                    <dd>Move down in search results</dd>
                    <dt>&#9166;</dt>
                    <dd>Go to active search result</dd>
                    <dt>+</dt>
                    <dd>Collapse/expand 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 = "std";
    </script>
    <script src="../../main.js"></script>
    <script defer src="../../search-index.js"></script>
</body>
</html>

Perl :: Catalyst :: PostgreSQL :: RPM Valid HTML 4.01 Transitional