rd_("AhReturn Euler\xe2\x80\x99s number.BhThe type sampled by this implementation.DfA <code>\\x</code> prefix. When used without brackets, this form is \xe2\x80\xa6AhGet field 0of this tuple0000AhGet field 1of this tuple0000CgThe Unicode scalar value corresponding to this literal.AhGet field 2of this tuple000CgReturns a reference to the private exponent of the key.AeThe private exponent.AhGet field 3of this tuple00CfReturns a reference to the public exponent of the key.ClThe public exponent, encoded in big-endian bytes without \xe2\x80\xa60AhGet field 4of this tuple0AhGet field 5of this tupleCdReturns the DSA base parameter of <code>self</code>.BnReturns a reference to the modulus of the key.CkThe public modulus, encoded in big-endian bytes without \xe2\x80\xa60CeReturns the DSA prime parameter of <code>self</code>.CnReturns a reference to the first factor of the exponent of \xe2\x80\xa6CmReturns the probability (<code>p</code>) of the distribution.BiThe first prime factor of <code>d</code>.BkReturns the pixel at the given coordinates.CiReturns the DSA sub-prime parameter of <code>self</code>.ClReturns a reference to the second factor of the exponent \xe2\x80\xa6BjThe second prime factor of <code>d</code>.DdReturns internal component <code>r</code> of an <code>DsaSig</code>.EfReturns internal component: <code>r</code> of an <code>EcdsaSig</code>. (See X9.62 \xe2\x80\xa6DdReturns internal component <code>s</code> of an <code>DsaSig</code>.EgReturns internal components: <code>s</code> of an <code>EcdsaSig</code>. (See X9.62 \xe2\x80\xa6o<code>as</code>n<code>@</code>AeThe type-level bit 0.0AeThe type-level bit 1.0BhA type alias for <code>BigEndian</code>.o<code>do</code>BgThe <code>==</code> operator (equality)n<code>=</code>CjAlias for the associated type of <code>IsEqual</code>: \xe2\x80\xa6AmA free-standing function: \xe2\x80\xa6CcA foreign function in an <code>extern</code> block.ChAn associated function within the definition of a trait.BlAn associated function within an impl block.o<code>fn</code>CjThe <code>&gt;=</code> operator (greater than or equal to)Ab<code>&gt;=</code>ClAlias for the associated type of <code>IsGreater</code>: \xe2\x80\xa6BmThe <code>&gt;</code> operator (greater than)Aa<code>&gt;</code>AoAn identifier of a kind of key.ClAn opaque ID that uniquely identifies a runtime relative \xe2\x80\xa6ClAn opaque ID that uniquely identifies a task relative to \xe2\x80\xa6CeIdentifies a span within the context of a subscriber.0DkAn <code>if</code> expression with an optional <code>else</code> block: \xe2\x80\xa6o<code>if</code>o<code>in</code>CmI/O errors, from APIs that accept <code>std::io</code> types.ClThe error was caused by a failure to read or write bytes \xe2\x80\xa6AeAn IO error occurred.0DaInitialization vector (nonce) used by <code>IvSizeUser</code> \xe2\x80\xa6BkA type alias for <code>LittleEndian</code>.CgThe <code>&lt;=</code> operator (less than or equal to)Ab<code>&lt;=</code>CiAlias for the associated type of <code>IsLess</code>: \xe2\x80\xa6BjThe <code>&lt;</code> operator (less than)Aa<code>&lt;</code>AkA message digest algorithm.BkThe <code>!=</code> operator (not equal to)o<code>!=</code>CjRun an unanchored search. This means a match may occur \xe2\x80\xa60B`200 OK [RFC9110, Section 15.3.1]BiSuccessful peer certificate verification.CoEquivalent to <code>Ok::&lt;_, anyhow::Error&gt;(value)</code>.AjContains the success value0AbIndicates success.CdThe type of successful values yielded by this future0002222AdOperation succeeded.3DcThe output type produced by this <code>Serializer</code> during \xe2\x80\xa60DcMust match the <code>Ok</code> type of our <code>Serializer</code>.000000110000000555555BiThe <code>||</code> operator (logical or)CaA pattern that matches any one of a set of cases.n<code>|</code>ChAlias for the associated type of <code>BitOr</code>: \xe2\x80\xa6BnReturn Archimedes\xe2\x80\x99 constant <code>\xcf\x80</code>.CjInforms the server of transfer encodings willing to be \xe2\x80\xa6Bn8 bits per pixel, stored in a <code>u8</code>.A`An Ipv4 address.A`An Ipv6 address.B`The type-level signed integer 0.0CmAdds a location to the error, such as a field or variant. \xe2\x80\xa6AeBigNum implementationCgAn additional set of certificates to include in the \xe2\x80\xa6CcSets the <code>ca</code> flag to <code>true</code>.Cm<code>p</code>\xe2\x80\x99s public Chinese Remainder Theorem exponent.Cm<code>q</code>\xe2\x80\x99s public Chinese Remainder Theorem exponent.CaGeneric data structure deserialization framework.0BoDeserialize JSON data to a Rust data structure.BcDeserialization support for the \xe2\x80\xa6AmDiffie-Hellman key agreement.BfReturns a copy of the internal DH key.nElliptic CurveCcChecks if both handles point to the same collector.ChPerforms a case-insensitive comparison of the string \xe2\x80\xa60BmDetermines if this point is equal to another.EgReturns <code>true</code> iff <code>a</code> and <code>b</code> contain the same bytes.DhDetermines if the elements of this <code>ParallelIterator</code> are \xe2\x80\xa6AlAsynchronous file utilities.11CiAn asynchronous, HTTP/2 server and client implementation.CmThe basic language/script/region components in the locale \xe2\x80\xa6BkThe data identifier for which to load data.AfThe ID of this marker.DaReturns the <code>Id</code> that represents the type of this key.AkReturns the SSL session ID.D`Returns the <code>Id</code> of the current <code>Runtime</code>.CnReturns the OS-assigned process identifier associated with \xe2\x80\xa6CjReturns the <code>Id</code> of the currently running task.ChReturns a task ID that uniquely identifies this task \xe2\x80\xa6ClReturns a task ID that identifies the task which errored \xe2\x80\xa61DiReturns the <code>Id</code> of the current <code>LocalSet</code> runtime.ChReturns this span\xe2\x80\x99s <code>Id</code>, if it is enabled.0DiBorrows the <code>Id</code> of the current span, if one exists and is \xe2\x80\xa6AaAsynchronous I/O.BmThe original IO object used in the handshake.0BoThe original IO object used before the upgrade.0BbSerialization and deserialization.CnTraits, helpers, and type definitions for asynchronous I/O \xe2\x80\xa6BiRepresents the <code>SIGIO</code> signal.AmHelpers for IO related tasks.CmThe inner transport used to read bytes to and write bytes \xe2\x80\xa6AnSets the <code>ip</code> flag.DeReturns true if <code>E</code> is the type held by this error object.CkReturn true if the underlying error has the same type as T.CdCheck whether the type is the same as <code>T</code>DbForwards to the method defined on the type <code>dyn Error</code>.DjReturns <code>true</code> if the inner type is the same as <code>T</code>.1EmReturns <code>true</code> if this <code>Subscriber</code> is the same type as <code>T</code>.000FdReturns <code>true</code> if this <code>Dispatch</code> forwards to a <code>Subscriber</code> of \xe2\x80\xa601111CjReturns the initialization vector, if the cipher uses one.CiZeroth order of the Bessel function of the first kind \xe2\x80\xa6CkFirst order of the Bessel function of the first kind (f64).CjInteger order of the Bessel function of the first kind \xe2\x80\xa6AgLittle-Endian utilitiesDhDetermines if the elements of this <code>ParallelIterator</code> are \xe2\x80\xa6BlReturns the natural logarithm of the number.01AjMessage digest algorithms.2AnSet the \xe2\x80\x9cno\xe2\x80\x9d proxy filter.ClCreate a future that is immediately ready with a success \xe2\x80\xa6BnGets a pending HTTP upgrade from this message.AeThe actual operation.EcThe type of Unicode op used to associate <code>name</code> with <code>value</code>.AkConvenient type operations.AlReborrow with a new lifetimeAbRuntime componentsAaRuntime utilitiesBmCreate a new haystack unit from a byte value.CjZeroth order of the Bessel function of the second kind \xe2\x80\xa6CiFirst order of the Bessel function of the second kind \xe2\x80\xa6CkInteger order of the Bessel function of the second kind \xe2\x80\xa6CjIndicates the time in seconds the object has been in a \xe2\x80\xa6AjA value with all bits set.CkA \xe2\x80\x9creasonable default\xe2\x80\x9d set of options which enables \xe2\x80\xa6DgReturns a <code>Ready</code> representing readiness for all operations.CnAVX but not AVX2: only 128-bit integer operations, but use \xe2\x80\xa6ClThe additionally authenticated data (AAD) for an opening \xe2\x80\xa6DfThe binary interface of a function: <code>extern &quot;C&quot;</code>.DaA <strong>type operator</strong> that returns the absolute value.BfThe <code>+</code> operator (addition)BgFuture for the <code>all</code> method.AlReport all possible matches.CmAll capture states, including those corresponding to both \xe2\x80\xa6CbThe <code>&amp;&amp;</code> operator (logical and)Ab<code>&amp;</code>CiAlias for the associated type of <code>BitAnd</code>: \xe2\x80\xa6BgFuture for the <code>any</code> method.EgOne arm of a <code>match</code> expression: <code>0..=10 =&gt; { return true; }</code>.ChAn abstract syntax tree for a single regular expression.cbmpChThe <strong>marker trait</strong> for compile time bits.A`<code>box</code>AiRead bytes from a buffer.0AeBuffer-related error.ccssccsvFhA <strong>type operator</strong> for comparing <code>Self</code> and <code>Rhs</code>. It provides a \xe2\x80\xa6BoThe CRC calculated by a <code>CrcReader</code>.CgA Certificate Revocation List; as specified in RFC 5280CgA Certificate Signing Request; as specified in RFC 2986ClUse a DFA. Warning: DFAs typically use a large amount of \xe2\x80\xa6BeA DFA implementation of Aho-Corasick.CmA hybrid NFA/DFA (also called a \xe2\x80\x9clazy DFA\xe2\x80\x9d) for regex \xe2\x80\xa6CiA dense table-based deterministic finite automaton (DFA).CkA one-pass DFA for executing a subset of anchored regex \xe2\x80\xa6CfA sparse deterministic finite automaton (DFA) with \xe2\x80\xa6BmIndicates the client\xe2\x80\x99s tracking preference.BjDER-encoded data, either owned or borrowedBfThe <code>/</code> operator (division)AnThe \xe2\x80\x9cany character\xe2\x80\x9d class.CjA type describing the different flavors of <code>.</code>.n<code>.</code>AmObject representing DSA keys.A`<code>dyn</code>ClMatch the end of text. Specifically, this matches at the \xe2\x80\xa60ChPseudo-token used for peeking the end of a parse stream.CkThe error was caused by prematurely reaching the end of \xe2\x80\xa6AgEuropean ordering rulesAhContains the error value000000BkAn error that visiting an AST might return.BkAn error that visiting an HIR might return.222222CfAlias for the associated type of <code>Pow</code>: \xe2\x80\xa6ClA 32-bit floating point number stored in big-endian byte \xe2\x80\xa6CjA 32-bit floating point number stored in little-endian \xe2\x80\xa6CkA 32-bit floating point number stored in network-endian \xe2\x80\xa6CjA 32-bit floating point number stored in native-endian \xe2\x80\xa6CiA 32-bit floating point number stored in a given byte \xe2\x80\xa6ClA 64-bit floating point number stored in big-endian byte \xe2\x80\xa6CjA 64-bit floating point number stored in little-endian \xe2\x80\xa6CkA 64-bit floating point number stored in network-endian \xe2\x80\xa6CjA 64-bit floating point number stored in native-endian \xe2\x80\xa6CiA 64-bit floating point number stored in a given byte \xe2\x80\xa6A`<code>for</code>fFridaycGETcgifDnA <strong>type operator</strong> that computes the greatest common divisor \xe2\x80\xa6CfAlias for the associated type of <code>Gcd</code>: \xe2\x80\xa6CjVariant of the 12-hour clock, sometimes used in Japan. \xe2\x80\xa6CiThe typical 12-hour clock. Hours are numbered 1\xe2\x80\x9312. \xe2\x80\xa6ClThe 24-hour clock. Hour are numbered 0\xe2\x80\x9323. Corresponds \xe2\x80\xa6ChA high-level intermediate representation (HIR) for a \xe2\x80\xa6ChA 16-bit signed integer stored in big-endian byte order.CkA 16-bit signed integer stored in little-endian byte order.CiA 16-bit signed integer stored in network-endian byte \xe2\x80\xa6CkA 16-bit signed integer stored in native-endian byte order.CeA 16-bit signed integer stored in a given byte order.ChA 32-bit signed integer stored in big-endian byte order.CkA 32-bit signed integer stored in little-endian byte order.CiA 32-bit signed integer stored in network-endian byte \xe2\x80\xa6CkA 32-bit signed integer stored in native-endian byte order.CeA 32-bit signed integer stored in a given byte order.ChA 64-bit signed integer stored in big-endian byte order.CkA 64-bit signed integer stored in little-endian byte order.CiA 64-bit signed integer stored in network-endian byte \xe2\x80\xa6CkA 64-bit signed integer stored in native-endian byte order.CeA 64-bit signed integer stored in a given byte order.DfThe concrete value for the type. Can be used in <code>const</code> \xe2\x80\xa6BgHelper type for <code>arr!</code> macroC`The primitive integer type with an identical \xe2\x80\xa6ChAn integer literal: <code>1</code> or <code>1u16</code>.CmUnary operator for retrieving the multiplicative inverse, \xe2\x80\xa6CbKey used by <code>KeySizeUser</code> implementors.BnA key used in a list of <code>Keywords</code>.BlA key used in a list of <code>Fields</code>.AnA key to use for HMAC signing.EjA <strong>type operator</strong> that gives the length of an <code>Array</code> or the \xe2\x80\xa6CiA <code>let</code> guard: <code>let Some(x) = opt</code>.A`<code>let</code>EbA literal in place of an expression: <code>1</code>, <code>&quot;foo&quot;</code>.BbA literal pattern: <code>0</code>.CfA Rust literal such as a string or integer or boolean.CjA trait encapsulating the operations required of a logger.AbThe maximum value.0AhThe maximum index value.11cmp4BgFuture for the <code>map</code> method.BgStream for the <code>map</code> method.DlA <code>Distribution</code> which maps sampled values to type <code>S</code>Df<code>Map</code> is an iterator that transforms the elements of an \xe2\x80\xa6C`The input contained a map that was not expected.0BaRepresents a JSON key/value type.0FdA <strong>type operator</strong> that returns the maximum of <code>Self</code> and <code>Rhs</code>.fUnusedFdA <strong>type operator</strong> that returns the minimum of <code>Self</code> and <code>Rhs</code>.EaA module or module declaration: <code>mod m</code> or <code>mod m { ... }</code>.A`<code>mod</code>CfAlias for the associated type of <code>Rem</code>: \xe2\x80\xa6fMondayBlThe <code>*</code> operator (multiplication)A`<code>mut</code>C`A contiguous NFA implementation of Aho-Corasick.CcA noncontiguous NFA implementation of Aho-Corasick.CeA byte oriented Thompson non-deterministic finite \xe2\x80\xa6BhThe <code>-</code> operator for negationBcA closure has not been executed yetBmA numerical identifier for an OpenSSL object.CmCommands that can instantiate as a no-op should implement \xe2\x80\xa6CaThe <code>!</code> operator for logical inversionn<code>!</code>EhThe base trait for numeric types, covering <code>0</code> and <code>1</code> values, \xe2\x80\xa6ChNo session caching for the client or server takes place.AdThe \xe2\x80\x9coff\xe2\x80\x9d level.0coggBbA constant <code>Ratio</code> 1/1.DiThe multiplicative identity element of <code>Self</code>, <code>1</code>.CaThe most significant bit of the number must be 1.BbA level lower than all log levels.BdAn HKDF OKM (Output Keying Material)CeFinds all occurrences of a single byte in a haystack.00D`Defines a multiplicative identity element for <code>Self</code>.oOne byte range.FnA <strong>Marker trait</strong> for the types <code>Greater</code>, <code>Equal</code>, and <code>Less</code>.CnInclude padding bytes when encoding, and require that they \xe2\x80\xa6cpdfoThe PEM format.cpngcPUTCkA pattern in a local binding, function signature, match \xe2\x80\xa6BfMarker trait for \xe2\x80\x9cplain old data\xe2\x80\x9d.BoBinary operator for raising a value to a power.DmA <strong>type operator</strong> that provides exponentiation by repeated \xe2\x80\xa6AnA HKDF PRK (pseudorandom key).DaA raw pointer type: <code>*const T</code> or <code>*mut T</code>.A`<code>pub</code>BlType corresponding to <code>SOCK_RAW</code>.CfOnly look for matches with a distance of 1, i.e do \xe2\x80\xa6lRaw DEFLATE.A`<code>raw</code>BoThe type representing a reference to this type.0A`<code>ref</code>Ab<code>ref x</code>BgReturns a reference to the inner value.BlA typed reference derived from a byte slice.BeThe <code>%</code> operator (modulus)De<code>Rev</code> is an iterator that produces elements in reverse \xe2\x80\xa6AmUser-level interface for RNGsCdA simple PRNG trait for use within tower middleware.AjRepublic of China calendarkAn RSA key.BeAn error occurred in the SSL library.csvghSaturdayAgA sequence of literals.CeThe input contained a sequence that was not expected.0BoThe <code>&lt;&lt;</code> operator (shift left)Ae<code>&lt;&lt;</code>C`The <code>&gt;&gt;</code> operator (shift right)Ae<code>&gt;&gt;</code>B`The state of an SSL/TLS session.EiThe input contained a <code>&amp;str</code> or <code>String</code> that was not expected.0CeA UTF-8 string literal: <code>&quot;foo&quot;</code>.BiThe <code>-</code> operator (subtraction)CfAlias for the associated type of <code>Add</code>: \xe2\x80\xa6fSundayC`Return the full circle constant <code>\xcf\x84</code>.BkProtocol corresponding to <code>TCP</code>.CaTab, spelled <code>\\t</code> (<code>\\x09</code>).CmAn escaped tab character (usually escaped as <code>\\t</code>)BdA possibly valid authentication tag.lAn HMAC tag.hThursdayBeA try-expression: <code>expr?</code>.A`<code>try</code>gTuesdayCaFinds all occurrences of two bytes in a haystack.00AkTwo successive byte ranges.Cf10 or 12 bits per pixel, stored in a <code>u16</code>.CjA 16-bit unsigned integer stored in big-endian byte order.CjA 16-bit unsigned integer stored in little-endian byte \xe2\x80\xa6CkA 16-bit unsigned integer stored in network-endian byte \xe2\x80\xa6CjA 16-bit unsigned integer stored in native-endian byte \xe2\x80\xa6CgA 16-bit unsigned integer stored in a given byte order.CjA 32-bit unsigned integer stored in big-endian byte order.CjA 32-bit unsigned integer stored in little-endian byte \xe2\x80\xa6CkA 32-bit unsigned integer stored in network-endian byte \xe2\x80\xa6CjA 32-bit unsigned integer stored in native-endian byte \xe2\x80\xa6CgA 32-bit unsigned integer stored in a given byte order.CjA 64-bit unsigned integer stored in big-endian byte order.CjA 64-bit unsigned integer stored in little-endian byte \xe2\x80\xa6CkA 64-bit unsigned integer stored in network-endian byte \xe2\x80\xa6CjA 64-bit unsigned integer stored in native-endian byte \xe2\x80\xa6CgA 64-bit unsigned integer stored in a given byte order.BkProtocol corresponding to <code>UDP</code>.C`The ULE type corresponding to <code>Self</code>.BeCustom derive for [<code>ULE</code>].CjFixed-width, byte-aligned data that can be cast to and \xe2\x80\xa6DjFull docs for this proc macro can be found on the <code>zerovec</code> \xe2\x80\xa6AoThe URI component of a request.D`A use declaration: <code>use alloc::collections::HashMap</code>.A`<code>use</code>BbAdded by proxies to track routing.BkType returned by <code>load_consume</code>.iWednesdaycxmlCiAlias for the associated type of <code>BitXor</code>: \xe2\x80\xa6CnRun an anchored search. This means that a match must begin \xe2\x80\xa60BgStream for the <code>zip</code> method.F`<code>Zip</code> is an iterator that zips up <code>a</code> and <code>b</code> into a single \xe2\x80\xa6C`Build an ioctl number for an argumentless ioctl.EgComputes the absolute value of <code>self</code>. Returns <code>Float::nan()</code> \xe2\x80\xa6CmComputes the absolute value of <code>self</code>. Returns \xe2\x80\xa6AlComputes the absolute value.02BkAdd the given pattern to this set to match.BgAdd together two <code>Interest</code>.DeComputes <code>a + b</code>, storing the result in <code>self</code>.BnAdd together two <code>Interest</code> values.C`Low level AES IGE and key wrapping functionalityBjGet a flags value with all known bits set.0DkExecute predicate over asynchronous stream, and return <code>true</code>\xe2\x80\xa60BjSet the target proxy for all destinations.DgReturns <code>CodePointInversionList</code> spanning entire Unicode \xe2\x80\xa6ChReturn the group representing all GeneralCategory valuesBkContains architecture independent routines.555555555555CnTests that every item in the parallel iterator matches the \xe2\x80\xa6CfCreate new storage for the offsets of all matching \xe2\x80\xa666DiSearches for <strong>some</strong> item in the parallel iterator that \xe2\x80\xa6BhAdds an argument to pass to the program.BkImplementation for <code>arr!</code> macro.CiMacro allowing for easy generation of Generic Arrays. \xe2\x80\xa6CoConvert a value to another, using the <code>as</code> operator.BgUtility types for working with the AST.CcDefines an abstract syntax for regular expressions.oThe actual ast.BhThe regular expression under repetition.BeThe regular expression in this group.DiReturns a reference to the underlying <code>syn</code> AST node which \xe2\x80\xa6DiReturns a <code>VariantAst</code> object which contains references to \xe2\x80\xa61DjReturns whether the bit in position <code>bit</code> is set, using the \xe2\x80\xa6CdReturns whether the bit in the given position is setA`Type-level bits.CnReturns <code>CodePointInversionList</code> spanning BMP rangeBcUtilities for working with buffers.CfTraits for data providers that produce opaque buffers.AdPlane configuration.CcLexicographically compares the elements of this \xe2\x80\xa6DhA convenience macro for comparing type numbers. Use <code>op!</code> \xe2\x80\xa6AnSMIME implementation using CMSBcThe cosine of <code>x</code> (f64).BmComputes the cosine of a number (in radians).0BlGet the Crc for this <code>CrcReader</code>.BlGet the Crc for this <code>CrcWriter</code>.AgDecrements self by one.CbRaw DER-encoded representation of the certificate.CeProvides direct access to a DFA implementation of \xe2\x80\xa6CjA module for building and searching with deterministic \xe2\x80\xa6CkToggle whether a fully compiled DFA should be available \xe2\x80\xa6BiTypes and routines specific to lazy DFAs.CgSet the lazy DFA compilation configuration for this \xe2\x80\xa6ClThe \xe2\x80\x9cOPENSSLDIR\xe2\x80\x9d setting of the library build in the \xe2\x80\xa6CfDNS Resolution used by the <code>HttpConnector</code>.AoSets the <code>dns</code> flag.AlCreate a \xe2\x80\x9cdot\xe2\x80\x9d AST item.BmReturns an HIR expression for <code>.</code>.AbDigital SignaturesBgReturns a copy of the internal DSA key.Ak&lt; start of output buffer0BgReturn the end position of this search.BaThe ending position of the match.BfThe end offset of the span, exclusive.ClReturns the end index of this window into the underlying \xe2\x80\xa6321BdThe inclusive end of the byte range.AdThe end byte offset.AfThe end of this range.AmReturn the end of this range.0AnEnd of byte range (inclusive).C`Check for remaining elements after passing a \xe2\x80\xa60AnFinish serializing a sequence.AkFinish serializing a tuple.BbFinish serializing a tuple struct.BcFinish serializing a tuple variant.AiFinish serializing a map.AlFinish serializing a struct.BdFinish serializing a struct variant.776543210DfThe <code>Deserializer::end</code> method should be called after a \xe2\x80\xa6CcInserts or updates an environment variable mapping.CnChecks whether the cursor is currently pointing at the end \xe2\x80\xa6BnCreate a new \xe2\x80\x9cend of input\xe2\x80\x9d haystack unit.ChCreate a unit that represents the \xe2\x80\x9cend of input\xe2\x80\x9d \xe2\x80\xa6AdError function (f64)CkCreate a future that is immediately ready with an error \xe2\x80\xa6BiThe underlying cache error that occurred.BbExponential, base <em>e</em> (f64)CjReturns <code>e^(self)</code>, (the exponential function).0CkPlaces the result of <code>a^p</code> in <code>self</code>.BkExtensions specific to the HTTP/2 protocol.BfExtensions for HTTP messages in Hyper.CjExtension traits to provide parsing methods on foreign \xe2\x80\xa6AhFused multiply add (f64)BlFormat this value as an identifier fragment.CjFormat an explanation of what data was being expected. \xe2\x80\xa60BaDisplay a JSON value as a string.CjAn implementation of the Fowler\xe2\x80\x93Noll\xe2\x80\x93Vo hash function.CnCalculates the Greatest Common Divisor (GCD) of the number \xe2\x80\xa600AnGreatest Common Divisor (GCD).FaPlaces the greatest common denominator of <code>a</code> and <code>b</code> in <code>self</code>.BcAlias for <code>Rng::random</code>.0CjReturns a reference to the value corresponding to the key.CmReturns a reference to the value in the set, if any, that \xe2\x80\xa6BkGets a reference to the value in the entry.BlReturns a reference to this entry\xe2\x80\x99s value.1CiGets a reference to the value that would be used when \xe2\x80\xa62CiGet a reference to a type previously inserted on this \xe2\x80\xa6CiReturns a reference to the value associated with the key.C`Get a reference to the first value in the entry.DhCreates a new <code>Builder</code> initialized with a GET method and \xe2\x80\xa6DaSend a <code>GET</code> request to the supplied <code>Uri</code>.CeLookup trie value by Unicode Scalar Value without \xe2\x80\xa60DgReturns the value that is associated with <code>char</code> in this \xe2\x80\xa6EdReturns a reference to the <code>Value</code> corresponding to the <code>Key</code>.0DeGet the value this map has associated with code point <code>ch</code>BcGet the property name given a value0AlBorrows the underlying data.AgGet the value for a keyAnQueries the trie for a string.CcGets a reference to the entry\xe2\x80\x99s value in the map.0DiReturn a reference to the stored value for <code>key</code>, if it is \xe2\x80\xa61ClReturn a reference to the value stored in the set, if it \xe2\x80\xa6BkGets a reference to the value in the entry.CmGet the value associated with <code>key</code>, if it exists.BkGets the reference to the underlying value.CmGets the reference to the result of this lazy value if it \xe2\x80\xa6BiGets a reference to the underlying value.0AjGets the underlying value.012C`Returns the contents of the OpenSSL error stack.CcReturns the first error on the OpenSSL error stack.ClReturns a reference to the element at the given index in \xe2\x80\xa6DiReturn the underlying <code>usize</code> value. The returned value is \xe2\x80\xa6BmGet the equivalence class for the given byte.CcReturn a reference to the lazily initialized value.CkGet a value from the pool. The caller is guaranteed to haveCjReturns a reference to the value corresponding to the key.=BlAccess the JSON text underlying a raw value.CnIndex into a JSON array or map. A string index can be used \xe2\x80\xa6CmReturn a reference to the value associated with the given \xe2\x80\xa6CmRead the inner value, applying an optimization barrier on \xe2\x80\xa6BgBorrows the element at the given index.ClReturns a reference to the value currently stored in the \xe2\x80\xa60ClReturns a copy of the task-local value if the task-local \xe2\x80\xa6BmObtain a valid reference to the yokeable dataBhGets a copy of the inner <code>T</code>.CnReturns the value as a primitive type, possibly performing \xe2\x80\xa600000000000AnQueries the trie for a string.0000DjGet one of this slice\xe2\x80\x99s elements, returning <code>None</code> if the \xe2\x80\xa6DiGets the element at the specified index. Returns <code>None</code> if \xe2\x80\xa6BjConvert to an <code>Option&lt;U&gt;</code>BnObtain this as an <code>Option&lt;T&gt;</code>BcGets GID (group ID) of the process.DkSimilar to <code>uid</code> but sets the group ID of the child process. \xe2\x80\xa6CdThe match semantics for the automaton that was used.0CnDefines a high-level intermediate (HIR) representation for \xe2\x80\xa6AgIncrements self by one.EhReturns the underlying <code>d_ino</code> field in the contained <code>dirent</code> \xe2\x80\xa6AkType-level signed integers.ChReturns the multiplicative inverse of <code>self</code>.CiZeroth order of the Bessel function of the first kind \xe2\x80\xa6CkFirst order of the Bessel function of the first kind (f32).CjInteger order of the Bessel function of the first kind \xe2\x80\xa6BjReturns a reference to this entry\xe2\x80\x99s key.BiGets a reference to the key in the entry.CgGets a reference to the key that would be used when \xe2\x80\xa620BhReturns a reference to the entry\xe2\x80\x99s key0BiReturns a reference to the entry\xe2\x80\x99s key.DkA macro allowing for compile-time construction of valid <code>Key</code>\xe2\x80\xa60CaGets a reference to the entry\xe2\x80\x99s key in the map.CiGets a reference to the key that was used to find the \xe2\x80\xa6ClGets a reference to the entry\xe2\x80\x99s key, either within the \xe2\x80\xa62276867BjReturn the key associated with this entry.CmCalculates the Lowest Common Multiple (LCM) of the number \xe2\x80\xa600AmLowest Common Multiple (LCM).B`Returns the length of this span.BaReturns the length of this match.CeReturns the number of patterns added to this builder.BaReturns the length of the vector.CkReturn the number of elements in the <code>ArrayVec</code>.B`Return the length of the string.DaReturns the number of bytes contained in this <code>Bytes</code>.DdReturns the number of bytes contained in this <code>BytesMut</code>.BiReturns the number of bytes in the slice.BiReturns the number of tasks in the deque.0BiReturns the number of tasks in the queue.BnReturns the number of fields in the structure.CcGets the number of individual errors in this error.CnReturn the number of messages in the queue or 0 if channel \xe2\x80\xa6CeReturns the number of futures contained in the queue.CcReturns the number of streams contained in the set.CcReturns the number of futures contained in the set.BjReturns the number of elements in the map.BjReturns the number of elements in the set.BlReturns the number of elements in the table.BgGet the number of extensions available.C`Returns the number of headers stored in the map.BhReturns the length of <code>self</code>.DaReturns the number of bytes contained in this <code>Bytes</code>.1CfReturn the number of key-value pairs in the map slice.C`Return the number of key-value pairs in the map.BoReturn the number of elements in the set slice.BiReturn the number of elements in the set.CbThe number of elements in the <code>LiteMap</code>BfReturns the size of the shared secret.BjReturns the number of bytes in the string.0C`Returns the number of bytes in the octet string.C`Computes an upper bound on the signature length.BiReturns the number of items in the stack.jThe lengthAmReturns the number of indicesCkProduces an exact count of how many items this iterator \xe2\x80\xa6B`Returns the length of this span.BaReturns the length of this match.CkReturns the total number of pattern identifiers in this \xe2\x80\xa6CnReturns the total number of look-around assertions in this \xe2\x80\xa6CcThe length of the haystack that exceeded the limit.BoReturns the number of codepoints in this range.BjReturns the number of bytes in this range.3CjReturns the number of literals in this sequence if the \xe2\x80\xa6BlReturns the length of this literal in bytes.CcReturns the number of byte ranges in this sequence.DfThe length that <code>Prk::expand()</code> should expand its input to.CoThe <code>OkmLength</code> given to <code>Prk::expand()</code>.BjReturns the number of elements in the map.BcReturn the number of stored values.BkThe number of elements stored in the vectorBjReturns the size of this address in bytes.AmReturns the number of fields.CnReturns the number of syntax tree nodes in this punctuated \xe2\x80\xa6BnReturns the number of messages in the channel.0BdReturns the number of queued values.CjReturns the number of messages that were sent into the \xe2\x80\xa6DbReturns the number of tasks currently in the <code>JoinSet</code>.CkReturns the number of fields in this <code>FieldSet</code>.DiReturns the number of fields in this <code>ValueSet</code> that would \xe2\x80\xa6CkReturns the number of fields that would be visited from \xe2\x80\xa6210ChThis function isn\xe2\x80\x99t used in this crate, but may be \xe2\x80\xa6BmReturns the length of the <code>Input</code>.BhGet the number of elements in this sliceBmReturns the number of elements in this slice.BdThe left hand side of the operation.BnThe natural logarithm of <code>x</code> (f64).AmA lightweight logging facade.AmLogs the <code>Record</code>.AkThe standard logging macro.CjReturns the logarithm of the number with respect to an \xe2\x80\xa60C`Apply some transform to the ident\xe2\x80\x99s string \xe2\x80\xa6DhMap <code>f</code> over the contained value and return the result in theCmMap this future\xe2\x80\x99s output to a different type, returning \xe2\x80\xa60CmMaps this stream\xe2\x80\x99s items to a different type, returning \xe2\x80\xa60ChReturns a locked view over a portion of the locked data.0DlMaps a <code>GenericSequence</code> to another <code>GenericSequence</code>.CjConsumes the request returning a new request with body \xe2\x80\xa6ClConsumes the response returning a new response with body \xe2\x80\xa6BlA map from names to their value discriminantChA map from the value discriminant (the index) to the \xe2\x80\xa60Dj<code>IndexMap</code> is a hash table where the iteration order of the \xe2\x80\xa6DkMakes a new <code>MappedMutexGuard</code> for a component of the locked \xe2\x80\xa60DiMakes a new <code>MappedReentrantMutexGuard</code> for a component of \xe2\x80\xa60DhMake a new <code>MappedRwLockReadGuard</code> for a component of the \xe2\x80\xa6DiMake a new <code>MappedRwLockWriteGuard</code> for a component of the \xe2\x80\xa610BiMap sampled values to type <code>S</code>0>DjApplies <code>map_op</code> to each item of this iterator, producing a \xe2\x80\xa6BeA map of String to serde_json::Value.EcReturns a <code>None</code> value if the option is <code>None</code>, otherwise \xe2\x80\xa67DiMakes a new <code>OwnedMappedMutexGuard</code> for a component of the \xe2\x80\xa680DhMakes a new <code>OwnedRwLockReadGuard</code> for a component of the \xe2\x80\xa6DkMakes a new <code>OwnedRwLockMappedWriteGuard</code> for a component of \xe2\x80\xa60DjMakes a new <code>RwLockReadGuard</code> for a component of the locked \xe2\x80\xa6DjMakes a new <code>RwLockMappedWriteGuard</code> for a component of the \xe2\x80\xa60BgReturns the most verbose logging level.BnReturns the most verbose logging level filter.BgReturns the maximum of the two numbers.00CmComputes the maximum of all the items in the iterator. If \xe2\x80\xa6BdThe maximum range of the repetition.AlMethod returning the maximumBgReturns the minimum of the two numbers.00CmComputes the minimum of all the items in the iterator. If \xe2\x80\xa6BdThe minimum range of the repetition.AlMethod returning the minimumCmMio is a fast, low-level I/O library for Rust focusing on \xe2\x80\xa6CiCreate a new error object from a printable error message.DeComputes <code>q * m</code>, storing the result in <code>self</code>.lReturns NaN.BcReturns the <code>NaN</code> value.AoNegate <code>Sign</code> value.AfNetworking primitives.BmTCP/UDP/Unix bindings for <code>tokio</code>.CcCreates a new Adler-32 instance with default state.CiCreate a new Aho-Corasick automaton using the default \xe2\x80\xa6ChCreate a new builder for configuring an Aho-Corasick \xe2\x80\xa6BmCreate a new error value with the given kind.CnCreate a new value that is represented by a \xe2\x80\x9csmall index.\xe2\x80\xa6CiCreate a new search configuration for the given haystack.C`Create a new match from a pattern ID and a span.CaCreate a new default configuration. A default \xe2\x80\xa6CiCreate a new builder for constructing a multi-pattern \xe2\x80\xa6CnA convenience function for constructing a searcher from an \xe2\x80\xa65CcCreate a new Aho-Corasick DFA using the default \xe2\x80\xa6CiCreate a new builder for configuring an Aho-Corasick DFA.CnCreate a new Aho-Corasick contiguous NFA using the default \xe2\x80\xa6:CiCreate a new Aho-Corasick noncontiguous NFA using the \xe2\x80\xa6;CkTakes an alignment value and a minimum valid alignment, \xe2\x80\xa6DeReturns a new <code>AVec&lt;T&gt;</code> with the provided alignment.EhCreates a new <code>ABox&lt;T&gt;</code> containing <code>value</code> at an address \xe2\x80\xa6BnCreate a new error object from any error type.BiCreate a new empty <code>ArrayVec</code>.BlCreate a new empty <code>ArrayString</code>.DbCreate a new <code>CapacityError</code> from <code>element</code>.BcCreate an <code>AtomicWaker</code>.CmCreate a <code>Base64Display</code> with the provided engine.CiCreate a new decoder that will read from the provided \xe2\x80\xa6ChCreate a new encoder that will write to the provided \xe2\x80\xa6ClCreate a EncoderStringWriter that will encode into a new \xe2\x80\xa6CmCreate a <code>GeneralPurpose</code> engine from an Alphabet.DfCreate a new config with <code>padding</code> = <code>true</code>, \xe2\x80\xa6DhCreate an <code>Alphabet</code> from a string of 64 unique printable \xe2\x80\xa6nDefine a flag.AmCreate new buffer from slice.BgCreates a new empty <code>Bytes</code>.CjCreates a new <code>BytesMut</code> with default capacity.DoCreates a <code>&amp;mut UninitSlice</code> wrapping a slice of initialised \xe2\x80\xa6CkCreates an iterator over the bytes contained by the buffer.CoConstructs a new <code>Unshared</code> from <code>inner</code>.BnCreate module with CPU feature detection code.BaCreate a new <code>Hasher</code>.AmCreates a new injector queue.DeAllocates <code>value</code> on the heap and returns a new atomic \xe2\x80\xa6DdAllocates <code>value</code> on the heap and returns a new owned \xe2\x80\xa6AhCreates a new collector.CcThe new value, which the operation failed to store.0BcCreates a new <code>Backoff</code>.CfPads and aligns a value to the length of a cache line.ClCreates a new atomic cell initialized with <code>val</code>.BbCreates a new <code>Parker</code>.BiCreates a new sharded reader-writer lock.CmCreates a new wait group and returns the single reference \xe2\x80\xa6BeCreate new value from fixed size key.CaCreate new value from fixed length key and nonce.BiCreates a new <code>Fields</code> struct.BfCreate a new <code>IdentString</code>.AbCreate a new list.DfCreate a new <code>ShapeSet</code> which includes the specified items.AkCreate new hasher instance.CfCreate new hasher instance with the given output size.BnInitialize hasher state for given output size.BoInstantiates a singleton representing this bit.0CdInstantiates a singleton representing the integer 0.AaCreate a new CRC.BdCreate a new <code>CrcReader</code>.BdCreate a new <code>CrcWriter</code>.CeCreate a new blank builder with no header by default.CmCreates a new object ready for compressing data that it\xe2\x80\x99\xe2\x80\xa6ClCreates a new object ready for decompressing data that it\xe2\x80\xa6CnCreates a new description of the compression level with an \xe2\x80\xa6CkCreates a new encoder which will read uncompressed data \xe2\x80\xa6CnCreates a new decoder which will decompress data read from \xe2\x80\xa6CnCreates a new encoder which will use the given compression \xe2\x80\xa6ClCreates a new decoder from the given reader, immediately \xe2\x80\xa6032CmCreates a new encoder which will write compressed data to \xe2\x80\xa6ClCreates a new decoder which will write uncompressed data \xe2\x80\xa6300105432254DjCreate a new <code>application/x-www-form-urlencoded</code> serializer \xe2\x80\xa6BbCreate a new, empty pool of tasks.DcCreate a <code>LocalFutureObj</code> from a custom trait object \xe2\x80\xa6CnCreate a <code>FutureObj</code> from a custom trait object \xe2\x80\xa6DgCreate a new <code>WakerRef</code> from a <code>Waker</code> reference.21DhCreates a new <code>Abortable</code> future/stream using an existing \xe2\x80\xa6DaCreates a new <code>AllowStdIo</code> from an existing IO object.DhCreates a new <code>BufReader</code> with a default buffer capacity. \xe2\x80\xa6DhCreates a new <code>BufWriter</code> with a default buffer capacity. \xe2\x80\xa6DjCreate a new <code>LineWriter</code> with default buffer capacity. The \xe2\x80\xa6CiCreates a new cursor wrapping the provided underlying \xe2\x80\xa6DkCreates a new window around the buffer <code>t</code> defaulting to the \xe2\x80\xa6BcCreate an <code>AtomicWaker</code>.8CcConstructs a new, empty <code>FuturesOrdered</code>BnConstructs a new, empty <code>SelectAll</code>CfConstructs a new, empty <code>FuturesUnordered</code>.BbCreates a new futures-aware mutex.CjReturns a new client builder instance initialized with \xe2\x80\xa6CjReturns a new server builder instance initialized with \xe2\x80\xa6BhCreates an empty <code>HashTable</code>.BhCreate an empty <code>Extensions</code>.BgCreate an empty <code>HeaderMap</code>.CfCreates a new blank <code>Request</code> with the bodyDiCreates a new default instance of <code>Builder</code> to construct a \xe2\x80\xa6CgCreates a new blank <code>Response</code> with the bodyDgCreates a new default instance of <code>Builder</code> to construct \xe2\x80\xa62CgReturns a new <code>SizeHint</code> with default valuesB`Create a new <code>Empty</code>.AoCreate a new <code>Full</code>.BbCreate a new <code>Limited</code>.BeCreate a new <code>StreamBody</code>.BeCreate a new <code>BodyStream</code>.BhCreate a new <code>BodyDataStream</code>BbCreate a new <code>BoxBody</code>.BhCreate a new <code>UnsyncBoxBody</code>.CgCreates a new Request, using a slice of headers you \xe2\x80\xa6EfCreates a new <code>Response</code> using a slice of <code>Header</code>s you have \xe2\x80\xa6BaCreates a new connection builder.0DdCreate a new <code>ReadBuf</code> with a slice of initialized bytes.B`Create a new connection builder.0=BgCreates a new empty <code>Bytes</code>.AhConstruct a new Builder.AnConstruct a new HttpConnector.CkCreate new <code>Connected</code> type with empty metadata.BgCreate a new SOCKSv5 handshake service.BfCreate a new SOCKSv4 handshake serviceAlCreate a new Tunnel service.BiConstruct a new <code>GaiResolver</code>.CkWraps the inner I/O in an <code>WithHyperIo&lt;I&gt;</code>CkWraps the inner I/O in an <code>WithTokioIo&lt;I&gt;</code>DkCreate new executor that relies on <code>tokio::spawn</code> to execute \xe2\x80\xa6CjWrap a type implementing Tokio\xe2\x80\x99s or hyper\xe2\x80\x99s IO traits.AgCreate a new TokioTimerBeCreate a new auto connection builder.DcCreate a new <code>TowerToHyperService</code> from a tower service.DhReturns a new <code>Char16Trie</code> with ownership of the provided \xe2\x80\xa6DiReturns a new <code>Char16TrieIterator</code> backed by borrowed data \xe2\x80\xa6DjReturns a new empty map of extensions. Same as <code>default()</code>, \xe2\x80\xa6DjReturns a new empty set of attributes. Same as <code>default()</code>, \xe2\x80\xa6ChReturns a new empty list of key-value pairs. Same as \xe2\x80\xa6BiReturns a new <code>SubdivisionId</code>.CjReturns a new empty map of Unicode extensions. Same as \xe2\x80\xa62ClReturns a new empty map of Transform extensions. Same as \xe2\x80\xa6ClReturns a new empty list of private-use extensions. Same \xe2\x80\xa6DiReturns a new empty list of variants. Same as <code>default()</code>, \xe2\x80\xa6DgConstructs a new <code>CanonicalComposition</code> using compiled data.DdConstructs a new <code>CanonicalCompositionBorrowed</code> using \xe2\x80\xa6AmConstruct from compiled data.000AmConstruct with compiled data.0DjCreates a new instance of <code>PropertyNamesLongBorrowed&lt;T&gt;</code>.DkCreates a new instance of <code>PropertyNamesShortBorrowed&lt;T&gt;</code>.EhCreates a new <code>CodePointSetDataBorrowed</code> for a <code>BinaryProperty</code>\xe2\x80\xa6DnCreates a new <code>CodePointSetData</code> for a <code>BinaryProperty</code>.EbCreates a new <code>CodePointMapData</code> for a <code>EnumeratedProperty</code>.CmCreates a new <code>CodePointMapDataBorrowed</code> for a \xe2\x80\xa6DlCreates a new <code>EmojiSetDataBorrowed</code> for a <code>EmojiSet</code>.0EaCreates a new instance of <code>PropertyParser&lt;T&gt;</code> using compiled \xe2\x80\xa6E`Creates a new instance of <code>PropertyParserBorrowed&lt;T&gt;</code> using \xe2\x80\xa687DgCreates a new instance of <code>ScriptWithExtensionsBorrowed</code> \xe2\x80\xa60EgCreates a <code>DataProviderWithMarker</code> from a <code>DataProvider</code> with \xe2\x80\xa6AgReturns an empty slice.BfCreate a new map. (Does not allocate.)1BfCreate a new set. (Does not allocate.)DkCreates a new IP network address from an <code>IpAddr</code> and prefix \xe2\x80\xa6DhCreates a new IPv4 network address from an <code>Ipv4Addr</code> and \xe2\x80\xa6DhCreates a new IPv6 network address from an <code>Ipv6Addr</code> and \xe2\x80\xa6CnThis is a cheap operation; you don\xe2\x80\x99t need to worry about \xe2\x80\xa6BgCreate a new empty <code>LiteMap</code>CgCreates a new mutex in an unlocked state ready for use.ClCreates a new reentrant mutex in an unlocked state ready \xe2\x80\xa6DlCreates a new instance of an <code>RwLock&lt;T&gt;</code> which is unlocked.BiConstruct new <code>RecordBuilder</code>.BmConstruct a new <code>MetadataBuilder</code>.CjReturns an iterator over all occurrences of the needle \xe2\x80\xa600ClCreate a new searcher that finds occurrences of the byte \xe2\x80\xa6CkCreate a new searcher that finds occurrences of the two \xe2\x80\xa6CmCreate a new searcher that finds occurrences of the three \xe2\x80\xa6CjCreate a new prefilter that reports possible locations \xe2\x80\xa6CcCreate a new pair of offsets from the given needle.CjCreate a new Rabin-Karp forward searcher for the given \xe2\x80\xa6CjCreate a new Rabin-Karp reverse searcher for the given \xe2\x80\xa6DkCreate a new Shift-Or forward searcher for the given <code>needle</code>\xe2\x80\xa6CiCreate a searcher that finds occurrences of the given \xe2\x80\xa60CnCreate a new searcher that finds occurrences of the needle \xe2\x80\xa600CiCreate a new pair searcher. The searcher returned can \xe2\x80\xa61110BiCreate a new finder for the given needle.CaCreate a new reverse finder for the given needle.CbCreate a new finder builder with default settings.BhA new iterator over mimes or media typesBnCreate an MZFlush value from an integer value.CoCreate a new <code>CompressorOxide</code> with the given flags.CiCreate a new tinfl_decompressor with all fields set to 0.AcCreate a new state.BfReturn a new <code>Poll</code> handle.B`Create a new <code>Waker</code>.BdCreate a new non-blocking Unix pipe.BnReturns a new connector with default settings.BiCreates a acceptor with default settings.BnCreates and initializes a <code>BigInt</code>.BoCreates and initializes a <code>BigUint</code>.CiFor a given n, iterate over all binomial coefficients \xe2\x80\xa6BaCreates a new <code>Ratio</code>.AiCreates a new empty cell.ChCreates a new lazy value with the given initializing \xe2\x80\xa6111110DbCreates a new <code>Deriver</code> using the provided private key.CoCreates a new <code>Hasher</code> with the specified hash type.AeCreates a new hasher.0000BiReturns a new <code>BigNumContext</code>.CcCreates a new <code>BigNum</code> with the value 0.AfCreates a new context.AnCreate a configuration parser.BkCreates a new point on the specified curve.BeCreates a new <code>Encrypter</code>.BeCreates a new <code>Decrypter</code>.B`Creates a new <code>Seal</code>.B`Creates a new <code>Open</code>.CbThis corresponds to <code>OSSL_LIB_CTX_new</code>.7CbThis corresponds to <code>OCSP_REQUEST_new</code>.CbCreates a new pkey context using the provided key.C`Creates a new <code>RsaPrivateKeyBuilder</code>.BbCreates a new <code>Signer</code>.BdCreates a new <code>Verifier</code>.BmCreates a new <code>SslContextBuilder</code>.BeCreates a new <code>SslStream</code>.DaBegin creating an <code>SslStream</code> atop <code>stream</code>AoCreates a new <code>Ssl</code>.EgCreates a new <code>Crypter</code>.  The initialisation vector, <code>iv</code>, is \xe2\x80\xa6AfCreates a new builder.0BlReturns a builder for a certificate request.CeCreates a new <code>X509StoreContext</code> instance.DjConstructs an X509 extension value. See <code>man x509v3_config</code> \xe2\x80\xa6BjReturns a builder for a certificate store.AiCreate an X509VerifyParamChConstruct a new <code>BasicConstraints</code> extension.C`Construct a new <code>KeyUsage</code> extension.ChConstruct a new <code>ExtendedKeyUsage</code> extension.ClConstruct a new <code>SubjectKeyIdentifier</code> extension.CnConstruct a new <code>AuthorityKeyIdentifier</code> extension.CnConstruct a new <code>SubjectAlternativeName</code> extension.CiCreates a new condition variable which is ready to be \xe2\x80\xa6BfCreates a new <code>Once</code> value.BdCreates a new <code>SpinWait</code>.DdReturns an empty <code>TokenStream</code> containing no token trees.DgCreates a new <code>Group</code> with the given delimiter and token \xe2\x80\xa6DfCreates a new <code>Punct</code> from the given character and spacing.EfCreates a new <code>Ident</code> with the given <code>string</code> as well as the \xe2\x80\xa6DhConstruct a new <code>Bernoulli</code> with the given probability of \xe2\x80\xa6DjCreate a new <code>Choose</code> instance which samples uniformly from \xe2\x80\xa6ClConstruct self, with inclusive lower bound and exclusive \xe2\x80\xa6DgCreate a new <code>Uniform</code> instance, which samples uniformly \xe2\x80\xa6EeCreates a new a <code>WeightedIndex</code> <code>Distribution</code> using the valuesDjCreate a new <code>ReseedingRng</code> from an existing PRNG, combined \xe2\x80\xa6DkCreate a <code>StepRng</code>, yielding an arithmetic sequence starting \xe2\x80\xa6DhCreate a new <code>BlockRng</code> from an existing RNG implementing \xe2\x80\xa60CmDeprecated in favor of <code>ThreadPoolBuilder::build</code>.CnCreates and returns a valid rayon thread pool builder, but \xe2\x80\xa610C`Creates and return a valid rayon thread pool \xe2\x80\xa6CiCreate a new search configuration for the given haystack.ChCreate a new half match from a pattern ID and a byte \xe2\x80\xa6C`Create a new match from a pattern ID and a span.CjCreate a new set of pattern identifiers with the given \xe2\x80\xa6BmCreate a new error value with the given kind.DfBuilds a <code>Regex</code> from a single pattern string using the \xe2\x80\xa6CiCreates a new <code>Cache</code> for use with this regex.CkCreate a new configuration object for a <code>Regex</code>.ClCreates a new builder for configuring and constructing a \xe2\x80\xa6CfReturn a new default dense DFA compiler configuration.CcCreate a new dense DFA builder with the default \xe2\x80\xa6CfParse the given regular expression using a default \xe2\x80\xa6C`Return a new default one-pass DFA configuration.CfCreate a new one-pass DFA builder with the default \xe2\x80\xa6ChParse the given regular expression using the default \xe2\x80\xa6BmCreate a new <code>onepass::DFA</code> cache.1CjCreate a new regex builder with the default configuration.55BjCreate a new cache for the given lazy DFA.CdReturn a new default lazy DFA builder configuration.CbCreate a new lazy DFA builder with the default \xe2\x80\xa65CdCreate a new cache for the given <code>Regex</code>.4BnCreate a new builder for hand-assembling NFAs.CiReturn a new default Thompson NFA compiler configuration.ChCreate a new NFA builder with its default configuration.<BjReturn a new default PikeVM configuration.CkCreate a new PikeVM builder with its default configuration.;BgCreate a new <code>PikeVM</code> cache.BiReturn a new default regex configuration.ClCreate a new BoundedBacktracker builder with its default \xe2\x80\xa6>CcCreate a new <code>BoundedBacktracker</code> cache.CgCreate a new fallible non-overlapping matches iterator.BiCreate a new default start configuration.BjReturn a new default syntax configuration.CkCreate a new <code>NonMaxUsize</code> from the given value.AiCreate a new small index.CnCreate a new value that is represented by a \xe2\x80\x9csmall index.\xe2\x80\xa60CiCreates a new default matcher for look-around assertions.CkCreate a new prefilter from a sequence of needles and a \xe2\x80\xa6CiCreates a new group info from a sequence of patterns, \xe2\x80\xa6DjCreate a new <code>Lazy</code> value that is initialized via the given \xe2\x80\xa6CjCreate a new pool. The given closure is used to create \xe2\x80\xa6CiCreate a new parser builder with a default configuration.CaCreate a new parser with a default configuration.BkCreate a new span with the given positions.CaCreate a new position with the given information.32AeCreate a new printer.BmCreate a new class from a sequence of ranges.CkCreate a new Unicode scalar value range for a character \xe2\x80\xa61BnCreate a new byte range for a character class.CdCreate a new extractor with a default configuration.ClReturns a sequence of exact literals from the given byte \xe2\x80\xa65CbCreate a new translator builder with a default \xe2\x80\xa6ChCreate a new translator using the default configuration.ChCreate a new iterator over UTF-8 byte ranges for the \xe2\x80\xa6BkConstructs a new <code>SystemRandom</code>.DcConstructs a new key from the given <code>UnboundKey</code> and \xe2\x80\xa6BeConstructs a <code>UnboundKey</code>.BfConstructs a <code>LessSafeKey</code>.BiConstructs a new <code>SealingKey</code>.BiConstructs a new <code>OpeningKey</code>.BcCreate a new header protection key.C`Constructs a new <code>UnparsedPublicKey</code>.AiConstructs a new context.DhConstructs a new <code>Salt</code> with the given value based on the \xe2\x80\xa6ChConstruct an HMAC signing key using the given digest \xe2\x80\xa6BoConstruct a new <code>UnparsedPublicKey</code>.AfCreate a new iterator.0CnThis is a cheap operation; you don\xe2\x80\x99t need to worry about \xe2\x80\xa6CiCreate a new borrowed deserializer from the given string.BoCreate a new deserializer from the given bytes.CnCreate a new borrowed deserializer from the given borrowed \xe2\x80\xa6CiConstruct a new <code>MapDeserializer&lt;I, E&gt;</code>.CiConstruct a new <code>SeqDeserializer&lt;I, E&gt;</code>.ClConstruct a new <code>SeqAccessDeserializer&lt;A&gt;</code>.ClConstruct a new <code>MapAccessDeserializer&lt;A&gt;</code>.CmConstruct a new <code>EnumAccessDeserializer&lt;A&gt;</code>.76543210AfMakes a new empty Map.CgCreate a JSON deserializer from one of the possible \xe2\x80\xa6CnCreate a JSON stream deserializer from one of the possible \xe2\x80\xa6CkCreate a JSON input source to read from a std::io input \xe2\x80\xa6CiCreate a JSON input source to read from a slice of bytes.CgCreate a JSON input source to read from a UTF-8 string.AnCreates a new JSON serializer.CiConstruct a pretty printer formatter that defaults to \xe2\x80\xa6BhReturns a new <code>Deserializer</code>.BfReturns a new <code>Serializer</code>.AkCreate new hasher instance.BfConstructs a new <code>Adler32</code>.BiConstruct a new, empty <code>Slab</code>.AiConstruct an empty vectorBkCreates a new socket and sets common flags.BcCreate new <code>SockFilter</code>.DbCreates a new <code>MaybeUninitSlice</code> wrapping a byte slice.ClCreate a new <code>MsgHdr</code> with all empty/zero fields.CoCreate a new <code>MsgHdrMut</code> with all empty/zero fields.DfCreate a <code>SockAddr</code> from the underlying storage and its \xe2\x80\xa6CeReturns a new, empty set of TCP keepalive parameters.DmThis method is used to construct a new <code>CtOption&lt;T&gt;</code> and \xe2\x80\xa6DjConstructs a new instance of <code>BlackBox</code> which will wrap the \xe2\x80\xa6DcUsually the <code>ParseStream::error</code> method will be used \xe2\x80\xa6EfCreates a new <code>Ident</code> with the given <code>string</code> as well as the \xe2\x80\xa6fPanicsCcInterpret a Syn literal from a proc-macro2 literal.DiCreates a <code>TokenBuffer</code> containing all the tokens from the \xe2\x80\xa6BeCreates an empty punctuated sequence.CnCreates a punctuated pair out of a syntax tree node and an \xe2\x80\xa6CfCreates a new static mutex containing the given value.DiCreate a new <code>Structure</code> with the variants and fields from \xe2\x80\xa6CmCreates a new runtime instance with default configuration \xe2\x80\xa6CfCreates a new lock in an unlocked state ready for use.DlCreates a new instance of an <code>RwLock&lt;T&gt;</code> which is unlocked.CcCreates a new empty <code>OnceCell</code> instance.CbCreates a new empty <code>SetOnce</code> instance.CjCreates a new barrier that can block a given number of \xe2\x80\xa6CoCreate a new <code>Notify</code>, initialized without a permit.CkCreates a new semaphore with the initial number of permits.CoCreates the sending-half of the <code>broadcast</code> channel.CkCreates the sending-half of the <code>watch</code> channel.CkCreates a new set of options with default mode/security \xe2\x80\xa6CkCreates a blank new set of options ready for configuration.0DkConstructs a new <code>Command</code> for launching the program at path \xe2\x80\xa6DcCreates a new <code>ReadBuf</code> from a fully initialized buffer.DhCreates a new <code>BufWriter</code> with a default buffer capacity. \xe2\x80\xa6DgWraps a type in both <code>BufWriter</code> and <code>BufReader</code>.DhCreates a new <code>BufReader</code> with a default buffer capacity. \xe2\x80\xa6DjCreates an <code>AsyncFd</code> backed by (and taking ownership of) an \xe2\x80\xa6BbCreate a new <code>JoinSet</code>.AmReturns a new local task set.DhCreates a new <code>CancellationToken</code> in the non-cancelled state.BhCreate a new <code>PollSemaphore</code>.E`Create a new <code>ReusableBoxFuture&lt;T&gt;</code> containing the provided \xe2\x80\xa6BfCreates a new <code>PollSender</code>.DdCreates a new <code>BytesCodec</code> for shipping around raw bytes.BoCreate a new, default, <code>FramedParts</code>DcReturns a <code>LinesCodec</code> for splitting up data into lines.DgReturns a <code>AnyDelimiterCodec</code> for splitting up data into \xe2\x80\xa6DkCreates a new <code>FramedWrite</code> with the given <code>encoder</code>.DjCreates a new <code>FramedRead</code> with the given <code>decoder</code>.EbProvides a <code>Stream</code> and <code>Sink</code> interface for reading and \xe2\x80\xa6CmCreates a new length delimited codec builder with default \xe2\x80\xa6DdCreates a new <code>LengthDelimitedCodec</code> with the default \xe2\x80\xa6CoConvert a stream of byte chunks into an <code>AsyncRead</code>.EhUse a <code>tokio::io::AsyncRead</code> synchronously as a <code>std::io::Read</code>\xe2\x80\xa6BfCreates a new <code>SinkWriter</code>.DoConvert an <code>AsyncRead</code> into a <code>Stream</code> with item type \xe2\x80\xa6FcCreate a new <code>InspectWriter</code>, wrapping <code>write</code> and calling <code>f</code> \xe2\x80\xa6FdCreate a new <code>InspectReader</code>, wrapping <code>reader</code> and calling <code>f</code> \xe2\x80\xa6BgCreates a new <code>CopyToBytes</code>.AiCreate a simplex channel.C`Create a new <code>Shared</code> from a service.CjCreates a new <code>RetryLayer</code> from a retry policy.CnRetry the inner service depending on this <code>Policy</code>.BmCreate a new <code>ExponentialBackoff</code>.DhCreate a <code>TpsBudget</code> that allows for a certain percent of \xe2\x80\xa6B`Create a timeout from a durationBbCreates a new <code>Timeout</code>AmConstruct a new elapsed errorBcCreate a new <code>BoxLayer</code>.BoCreate a new <code>BoxCloneServiceLayer</code>.CcCreate a new <code>BoxCloneSyncServiceLayer</code>.BjCreate a new <code>BoxCloneService</code>.BnCreate a new <code>BoxCloneSyncService</code>.BkCreates a new <code>AndThen</code> service.BnCreates a new <code>AndThenLayer</code> layer.BkCreate new <code>CallAll</code> combinator.CdCreate new <code>CallAllUnordered</code> combinator.CnReturns a new <code>FutureService</code> for the given future.BjCreates a new <code>MapErr</code> service.BgCreates a new <code>MapErrLayer</code>.BnCreates a new <code>MapRequest</code> service.BkCreates a new <code>MapRequestLayer</code>.BoCreates a new <code>MapResponse</code> service.CbCreates a new <code>MapResponseLayer</code> layer.BmCreates a new <code>MapResult</code> service.C`Creates a new <code>MapResultLayer</code> layer.BmCreates a new <code>MapFuture</code> service.C`Creates a new <code>MapFutureLayer</code> layer.BcCreate a new <code>Optional</code>.BhCreates a new <code>Then</code> service.BkCreates a new <code>ThenLayer</code> layer.BlCreate a new default <code>HasherRng</code>.BiCreate a new <code>ServiceBuilder</code>.BhCreate a new <code>Identity</code> valueB`Create a new <code>Stack</code>.10ClConstruct new metadata for a span or event, with a name, \xe2\x80\xa6EcReturns a <code>Dispatch</code> that forwards to the given <code>Subscriber</code>.DbReturns a new <code>Event</code> in the current span, with the \xe2\x80\xa6DhConstructs a new <code>FieldSet</code> with the given array of field \xe2\x80\xa6BhReturns a new <code>NoSubscriber</code>.DiConstructs a new <code>Span</code> with the given metadata and set of \xe2\x80\xa6DfReturns <code>Attributes</code> describing a new child span of the \xe2\x80\xa6DbConstructs a new <code>Record</code> from a <code>ValueSet</code>.BfCreates a new <code>Once</code> value.5EdReturns a new <code>DefaultCallsite</code> with the specified <code>Metadata</code>.98732DdConstructs a new <code>Current</code> that indicates the current \xe2\x80\xa66BoCreate a <code>TryLock</code> around the value.BoInstantiates a singleton representing this bit.0CgInstantiates a singleton representing this strictly \xe2\x80\xa60CdInstantiates a singleton representing the integer 0.2CgInstantiates a singleton representing this unsigned \xe2\x80\xa60DhConstruct a new Reader for the given input. Use <code>read_all</code> orBgCreates the iterator from a byte slice.00BbAllocates and returns a new plane.AgCreates a new iterator.BgCreate a new <code>want</code> channel.CjCreate a builder that will perform revocation checking \xe2\x80\xa6BjConstruct a new <code>KeyPurposeId</code>.BfConstructs a new <code>Unalign</code>.CmConstructs a new value, possibly performing an endianness \xe2\x80\xa600000000000DgMove value inside a <code>Zeroizing</code> wrapper which ensures it \xe2\x80\xa6CfCreates a new, empty <code>VarZeroVec&lt;T&gt;</code>.CmCreates a new, borrowed, empty <code>ZeroVec&lt;T&gt;</code>.DnNew <code>NichedOptionULE&lt;U, N&gt;</code> from <code>Option&lt;U&gt;</code>ElConstruct an <code>OptionULE&lt;U&gt;</code> from an equivalent <code>Option&lt;T&gt;</code>CnThis is a cheap operation; you don\xe2\x80\x99t need to worry about \xe2\x80\xa6AmCreates a new zstd compressorB`Creates a new zstd decompressor.AfCreates a new decoder.AfCreates a new encoder.1001BbCreates a new <code>Reader</code>.DfCreates a new <code>Writer</code> with a fixed buffer capacity of 32KBCdProvides direct access to NFA implementations of \xe2\x80\xa6CnProvides non-deterministic finite automata (NFA) and regex \xe2\x80\xa6CjA collection of numerical identifiers for OpenSSL objects.BiReturns the NID associated with this OID.AkReturns the cipher\xe2\x80\x99s Nid.0DgThe bitwise negation (<code>!</code>) of the bits in a flags value, \xe2\x80\xa600000000000CmReturn an <code>Instant</code> representing the current time.0BlThe current time, as a <code>UnixTime</code>BnReturns an instant corresponding to \xe2\x80\x9cnow\xe2\x80\x9d.CeReturns the <code>num</code> parameter of the cipher.CdReturns the multiplicative identity, <code>1</code>.EaReturns the multiplicative identity element of <code>Self</code>, <code>1</code>.AlEnables or disables padding.CfGenerates the pattern fragment for this field binding.CjGenerates the match-arm pattern which could be used to \xe2\x80\xa6AlLow-level PEM decoding APIs.BeGets PID (process ID) of the process.AhPins the current thread.A`Pins the handle.AjPins a value on the stack.CgRemove the last value from the vector if it exists, \xe2\x80\xa6CdRemove the last element in the vector and return it.CjRemoves the last character from the string and returns it.AkPops a task from the queue.AnRemove the last key-value pairAeRemove the last valueCgRemoves the last element from the stack and returns it.ClRemove an item from the end of the vector and return it, \xe2\x80\xa6CkRemoves the last punctuated pair from this sequence, or \xe2\x80\xa6BdReturns the current cursor position.000Ci&lt; position where reading stopped. Will be updated. \xe2\x80\xa6Ci&lt; position where writing stopped. Will be updated. \xe2\x80\xa610ClReturns <code>x</code> to the power of <code>y</code> (f64).BeReturns <code>self ^ exponent</code>.0CjRaises the <code>Ratio</code> to the power of an exponent.DiRaises self to the power of <code>exp</code>, using exponentiation by \xe2\x80\xa6ClRaises a value to the power of exp, using exponentiation \xe2\x80\xa6ChReturns <code>self</code> to the power <code>rhs</code>.EfTransfer bytes into <code>self</code> from <code>src</code> and advance the cursor \xe2\x80\xa60DhCreates a new <code>Builder</code> initialized with a PUT method and \xe2\x80\xa6CdPushes the errors back onto the OpenSSL error stack.CcPushes the error back onto the OpenSSL error stack.CcConsumes this guard and puts it back into the pool.BhReturns the underlying raw mutex object.0CeReturns the underlying raw reader-writer lock object.CaUnsafe functions that mirror the API of the C \xe2\x80\xa6BoRaw in-memory stream compression/decompression.CnProduces a new iterator with the elements of this iterator \xe2\x80\xa6BeThe right hand side of the operation.AoSets the <code>rid</code> flag.BhAccess a fast, pre-initialized generatorBdPRNG utilities for tower middleware.mReturn a lineClThis version of the function includes the padding on the \xe2\x80\xa6BfRivest\xe2\x80\x93Shamir\xe2\x80\x93Adleman cryptosystemBgReturns a copy of the internal RSA key.dRSA.BhRun all tasks in the pool to completion.CiExecutes the main loop for this thread. This will not \xe2\x80\xa60BiPerforms a single step of this operation.Algithub\xe2\x80\x82crates-io\xe2\x80\x82docs-rsAnSequence-related functionalityBoGeneric data structure serialization framework.0BoSerialize a Rust data structure into JSON data.BaSerialization support for the \xe2\x80\xa6FnCall <code>Flags::insert</code> when <code>value</code> is <code>true</code> or <code>Flags::remove</code> \xe2\x80\xa60BgSet buffer content and cursor position.ChChanges the range of this window to the range specified.CbA hash set implemented using <code>IndexMap</code>CeSets the contents of this cell to <code>value</code>.00000ChSets the ASN.1 value to the value of a signed 32-bit \xe2\x80\xa6GkCall <code>insert</code> when <code>value</code> is <code>true</code> or <code>remove</code> when <code>value</code> is \xe2\x80\xa600000000000BmSet the equivalence class for the given byte.DiSets the value of the <code>OnceCell</code> to the given value if the \xe2\x80\xa6DhSets the value of the <code>SetOnce</code> to the given value if the \xe2\x80\xa6C`Replace the future currently stored in this box.CkSets the inner <code>T</code>, dropping the previous value.ClUpdates the value in place as a primitive type, possibly \xe2\x80\xa600000000000AiThe SHA family of hashes.BaThe sine of <code>x</code> (f64).BkComputes the sine of a number (in radians).0CkPlaces the result of <code>a\xc2\xb2</code> in <code>self</code>.Aj&lt; start of input buffer0A`SSL/TLS support.DhReturns a shared reference to the <code>Ssl</code> object associated \xe2\x80\xa60DaReturns a shared reference to the <code>Ssl</code> of the stream.BcParallel iterator types for stringsDmReturns the difference of <code>self</code> and <code>rhs</code> as a new \xe2\x80\xa6CbReturns the set difference, cloned into a new set.CeThe intersection of a source flags value with the \xe2\x80\xa600000000000CkThe expression inside the capturing group, which may be \xe2\x80\xa6AnThe expression being repeated.BcReturns the current crc32 checksum.BbSums up the items in the iterator.Algithub\xe2\x80\x82crates-io\xe2\x80\x82docs-rsBjReturns the tag stored within the pointer.0ChRetrieves the calculated authentication tag from the \xe2\x80\xa6BdThe tangent of <code>x</code> (f64).BnComputes the tangent of a number (in radians).0AbTCP utility types.BiSupport all versions of the TLS protocol.DaGets the value of the <code>IP_TTL</code> option for this socket.00000BbGets UID (user ID) of the process.ClSets the child process\xe2\x80\x99s user ID. This translates to a \xe2\x80\xa6ChTraits that data provider implementations can use to \xe2\x80\xa6CmTraits over unaligned little-endian data (ULE, pronounced \xe2\x80\xa6BjReturns a reference to the associated URI.AmSet the URI for this request.AcThe request\xe2\x80\x99s URIBkURI component of request and response linesCdGet the <code>http::Uri</code> for the target proxy.DeReturns the contents of this <code>GeneralName</code> if it is an \xe2\x80\xa6AoSets the <code>uri</code> flag.CoParallel iterator types for vectors (<code>Vec&lt;T&gt;</code>)CjZeroth order of the Bessel function of the second kind \xe2\x80\xa6CiFirst order of the Bessel function of the second kind \xe2\x80\xa6CkInteger order of the Bessel function of the second kind \xe2\x80\xa6BoWrappers around raw operations implementing \xe2\x80\xa6BlAn adapter for zipping two streams together.0DdCombines two <code>GenericSequence</code> instances and iterates \xe2\x80\xa6EeIterates over tuples <code>(A, B)</code>, where the items <code>A</code> are from \xe2\x80\xa6CjIterates tuples, repeating the element with items from \xe2\x80\xa6CbAligned box. See [<code>Box</code>] for more info.A`The ASN1 format.CeAligned vector. See [<code>Vec</code>] for more info.BcAlias to make it easy to add 1: \xe2\x80\xa6CmTrait implemented by types which have a span <code>Id</code>.CmAutomatically detect whether a heuristic prefilter should \xe2\x80\xa6Aa<code>auto</code>CjEnable session caching on both the client and server side.CbBell, spelled <code>\\a</code> (<code>\\x07</code>).CnBest quality of compression, usually produces the smallest \xe2\x80\xa6AiThe underlying bits type.CiA bits type that can be used as storage for a flags type.Ek<code>Self</code> <em>must</em> have the same layout as the specified <code>Bits</code> \xe2\x80\xa6CgTrait representing a streaming body of a Request or \xe2\x80\xa60CjThe input contained a boolean value that was not expected.0AjRepresents a JSON boolean.0CkA boolean literal: <code>true</code> or <code>false</code>.BnSupport both anchored and unanchored searches.0AkAdd for fields and genericsBjA byte literal: <code>b&#39;f&#39;</code>.AcCompression contextn<code>R</code>DaA nul-terminated C-string literal: <code>c&quot;foo&quot;</code>.CfA function call expression: <code>invoke(a, b)</code>.DdThe type of the \xe2\x80\x9ccart\xe2\x80\x9d that is used by <code>DataPayload</code>.BkA cast expression: <code>foo as f64</code>.AjA parsed X509 certificate.CnThe input contained a <code>char</code> that was not expected.0BnA character literal: <code>&#39;a&#39;</code>.CnFuture wrapper to ensure cooperative scheduling created by \xe2\x80\xa6BlFuture for the <code>copy()</code> function.BiType wrapped by <code>CoreWrapper</code>.BbAlias to make it easy to cube. \xe2\x80\xa6CgContains the date and time at which the message was \xe2\x80\xa6BmType corresponding to <code>SOCK_DCCP</code>.BlProtocol corresponding to <code>DCCP</code>.AhA Decompression Context.CmPunctuation characters explicitly called out as dashes in \xe2\x80\xa6AfA struct or enum body.BhValues yielded by the <code>Body</code>.0CiRegular baked data: a trie for lookups and a slice of \xe2\x80\xa6DgError in inflation; see <code>inflate::stream::inflate()</code> for \xe2\x80\xa6ClThe error was caused by input data that was semantically \xe2\x80\xa6CfThe storage of a struct, enum or union data structure.CjTreat unknown revocation status as an error condition, \xe2\x80\xa6BnDictionary style ordering (such as in Sinhala)CfAlias for the associated type of <code>Sub</code>: \xe2\x80\xa6BbThe output of the completed future0CgCompression succeeded and the deflate stream was ended.BfFinished decompression without issues.BeA closure has completed successfully.C`Identifier for a specific version of a resource.BgThe element type of the trailing slice.Aa<code>else</code>CbThe input contained an enum that was not expected.0DeAn enum definition: <code>enum Foo&lt;A, B&gt; { A(A), B(B) }</code>.Aa<code>enum</code>o<code>==</code>BoExpression, with or without trailing semicolon.AbA Rust expression.dfontCkContains an Internet email address for a human user who \xe2\x80\xa6CnA state that cannot be transitioned out of. This is useful \xe2\x80\xa6AfThe trie type is fast.CkRepresents the \xe2\x80\x9cfast\xe2\x80\x9d type code point tries for the \xe2\x80\xa6BhFuture for the <code>feed</code> method.DiMarker type corresponding to the <code>X509_LOOKUP_file</code> lookup \xe2\x80\xa6BdA complete file of Rust source code.BnA reference to an open file on the filesystem.BjTypes which may be filled with random dataCcA defined flags value that may be named or unnamed.CmA meta-item that can be present as a word - with no value \xe2\x80\xa6AiA single flag in a group.nA single flag.BhFuture for the <code>fold</code> method.Dd<code>Fold</code> is an iterator that applies a function over an \xe2\x80\xa6ClSyntax tree traversal to transform the nodes of an owned \xe2\x80\xa6AlFour successive byte ranges.DbAll output is flushed as with <code>Flush::Sync</code> and the \xe2\x80\xa6BgA body that consists of a single chunk.DgSame as <code>Sync</code>, but resets the compression dictionary so \xe2\x80\xa6DcSame as <code>Sync</code>, but reset the dictionary so that the \xe2\x80\xa6CiThe data could not be sent on the channel because the \xe2\x80\xa6BhFuture for the <code>fuse</code> method.BhStream for the <code>fuse</code> method.Bc410 Gone [RFC9110, Section 15.5.11]CiA glob import in a <code>use</code> item: <code>*</code>.DkThe empty variant after the result of a <code>MaybeDone</code> has been \xe2\x80\xa6DiThe empty variant after the result of a <code>TryMaybeDone</code> has \xe2\x80\xa6DcAlias for the associated type of <code>IsGreaterOrEqual</code>: \xe2\x80\xa6dHEADFd<code>enabled!</code> callsite. <code>Subscriber</code>s can assume this <code>Kind</code> means \xe2\x80\xa6ClSpecifies the domain name of the server and (optionally) \xe2\x80\xa6dhtmlAdHTTP protocol schemeCiA 128-bit signed integer stored in big-endian byte order.CiA 128-bit signed integer stored in little-endian byte \xe2\x80\xa6CjA 128-bit signed integer stored in network-endian byte \xe2\x80\xa6CiA 128-bit signed integer stored in native-endian byte \xe2\x80\xa6CfA 128-bit signed integer stored in a given byte order.DcThe single <code>DataMarkerInfo</code> associated with this marker.AeThe \xe2\x80\x9cinfo\xe2\x80\x9d level.000BdInitial value for an unlocked mutex.nInitial value.1CbInitial value for an unlocked <code>RwLock</code>.DeDomain for IPv4 communication, corresponding to <code>AF_INET</code>.DfDomain for IPv6 communication, corresponding to <code>AF_INET6</code>.AlNo available work was found.0CfAn impl block providing trait or associated items: \xe2\x80\xa6Aa<code>impl</code>8BoCorresponds to the <code>Info</code> log level.AjThe type for initializers.AmValues yielded by the stream.0BlResults element type, e.g. <code>u32</code>.CiThe type of item that the parallel iterator will produce.CmThe type of item that the parallel iterator will produce. \xe2\x80\xa6CmThe type of item that will be produced; this is typically \xe2\x80\xa6CnThe type of item that this parallel iterator produces. For \xe2\x80\xa622CkThe type of item that will be produced by this producer \xe2\x80\xa6BkThe type of item returned by this producer.CiAn item, which can be a single literal, range, nested \xe2\x80\xa6BcThe type of the array\xe2\x80\x99s elements.AcAn item definition.CiThings that can appear directly inside of a module or \xe2\x80\xa6AkThe type of decoded frames.AnAn iterator over flags values.BjStream for the <code>iter</code> function.ClImmutable iterator over all the futures in the unordered \xe2\x80\xa6CiImmutable iterator over all streams in the unordered set.DgAn iterator over the entries of a <code>HashMap</code> in arbitrary \xe2\x80\xa6CeAn iterator over the items of a <code>HashSet</code>.DiAn iterator over the entries of a <code>HashTable</code> in arbitrary \xe2\x80\xa6Bf<code>HeaderMap</code> entry iterator.CiAn iterator over the entries of an <code>IndexMap</code>.CgAn iterator over the items of an <code>IndexSet</code>.Am<code>Events</code> iterator.BhAn iterator over the stack\xe2\x80\x99s contents.BlAn iterator over a <code>Distribution</code>C`The parallel iterator type that will be created.ChThe type of the parallel iterator that will be returned.BjThe type of iterator that will be created.CiThe draining parallel iterator type that will be created.0DiA parallel iterator over a reference to the <code>Some</code> variant \xe2\x80\xa6CiParallel iterator over an immutable reference to a resultCaParallel iterator over immutable items in a sliceCkParallel iterator over an immutable reference to a hash mapCkParallel iterator over an immutable reference to a hash setCmParallel iterator over an immutable reference to a binary \xe2\x80\xa6CmParallel iterator over an immutable reference to a B-Tree \xe2\x80\xa60CmParallel iterator over an immutable reference to a linked \xe2\x80\xa6CfParallel iterator over an immutable reference to a \xe2\x80\xa6CgParallel iterator over a range, implemented for all \xe2\x80\xa6CnParallel iterator over an inclusive range, implemented for \xe2\x80\xa6BoAn iterator over a serde_json::Map\xe2\x80\x99s entries.CkAn iterator over the values stored in the <code>Slab</code>CmAn iterator over borrowed values of type <code>&amp;T</code>.BaAn iterator over a set of fields.0djpegdjsonBjFuture for the <code>join</code> function.EdJoins two values implementing <code>AsyncRead</code> and <code>AsyncWrite</code> \xe2\x80\xa6ClSerialize using JavaScript Object Notation (JSON), using \xe2\x80\xa6DkAn iterator over the keys of a <code>HashMap</code> in arbitrary order. \xe2\x80\xa6BmAn iterator over <code>HeaderMap</code> keys.CfAn iterator over the keys of an <code>IndexMap</code>.BlAn iterator over a serde_json::Map\xe2\x80\x99s keys.CbIndicates whether the callsite is a span or event.CnAllows the server to point an interested client to another \xe2\x80\xa6AlReturn <code>ln(2.0)</code>.ChLazy block buffer kind, which guarantees that buffer \xe2\x80\xa6BjFuture for the <code>lazy</code> function.CaA value which is initialized on the first access.0EaA lazily initialized value that implements <code>Deref</code> for <code>T</code>.D`Alias for the associated type of <code>IsLessOrEqual</code>: \xe2\x80\xa6CdTruncate left side, i.e. <code>&amp;out[..n]</code>.AoA value of type <code>L</code>.AhFirst branch of the typeAfPoll the first stream.AnA value of type <code>L</code>3DiA potential output from <code>Cmp</code>, this is the type equivalent \xe2\x80\xa6CkGeneric helper for libm functions, abstracting over f32 \xe2\x80\xa6BoA structured list within an attribute, like \xe2\x80\xa6CmAlias for the associated type of <code>Logarithm2</code>: \xe2\x80\xa6CkA conditional epsilon transition satisfied via some sort ofAhA look-around assertion.CkA look-around assertion. A look-around match always has \xe2\x80\xa6CdThe high-level intermediate representation for a \xe2\x80\xa6BnConditionless loop: <code>loop { ... }</code>.Aa<code>loop</code>dmpegCa(<code>M</code>) The union of all mark categoriesBiCharacters used in mathematical notation.CeThe literal is written as an escape because it is \xe2\x80\xa6BoContent of a compile-time structured attribute.AlA parsed mime or media type.Aa<code>move</code>n<code>x</code>AiThe name of this property00BnType-level signed integers with negative sign.CbDisables verification of the peer\xe2\x80\x99s certificate.CjA constant RawValue with the JSON value <code>null</code>.BkA domain name to resolve into IP addresses.BaA section of a <code>Mime</code>.DhAn identifier imported by a <code>use</code> item: <code>HashMap</code>.BhFuture for the <code>next</code> method.CiDummy operation that just copies its input to the output.CeNo match was found. Since false negatives are not \xe2\x80\xa6BfA typical parameter for passing to \xe2\x80\xa60iNo value.CjDon\xe2\x80\x99t use sentence break suppressions data (the default)BiRepresents Bidi_Paired_Bracket_Type=None.AbNo-op rename rule.BkNever used a prefilter in substring search.ClDon\xe2\x80\x99t force any flushing. Used when more input data is \xe2\x80\xa6AaNormal operation.66666666666Ah<code>\xe2\x88\x85 ... \xe2\x88\x85</code>CeNo capture states are compiled into the Thompson NFA.dNoneDbError returned if the inner <code>Service</code> has not been set.AmRepresents a JSON null value.0oAn OSCP status.AoCompression succeeded normally.CaA stream which emits single element and then EOF.CjA synchronization primitive which can be used to run a \xe2\x80\xa6CfIterator adaptor for the <code>once()</code> function.CmA low-level synchronization primitive for one-time global \xe2\x80\xa6BiRepresents Bidi_Paired_Bracket_Type=Open.AoRepresents an EVP_Open context.o<code>|=</code>o<code>||</code>CbVerifies that the peer\xe2\x80\x99s certificate is trusted.BnType-level signed integers with positive sign.AhA public or private key.dPOSTCkA pair of byte offsets into a needle to use as a predicate.DdA single syntax tree node of type <code>T</code> followed by its \xe2\x80\xa6Da<code>Part</code>s are used as annotations for formatted strings.DkA path like <code>core::mem::replace</code> possibly containing generic \xe2\x80\xa6DlA path prefix of imports in a <code>use</code> item: <code>core::...</code>.DhA path pattern like <code>Color::Red</code>, optionally qualified with aDkA path like <code>core::slice::Iter</code>, optionally qualified with a \xe2\x80\xa6CbA path at which a named item is exported (e.g. \xe2\x80\xa6CbFuture for the <code>Peekable::peek</code> method.CfTypes that can be parsed by looking at just one token.DaA perl character class, e.g., <code>\\d</code> or <code>\\W</code>.CnSent via <code>PingPong</code> to send a PING frame to a peer.n<code>+</code>CdPolls for readiness events on all registered values.E`Received via <code>PingPong</code> when a peer acknowledges a <code>Ping</code>.DdA thread safe pool that works in an <code>alloc</code>-only context.AlThe port component of a URI.Aa<code>priv</code>CfAlias for the associated type of <code>Mul</code>: \xe2\x80\xa6CdThe search saw a \xe2\x80\x9cquit\xe2\x80\x9d byte at which it was \xe2\x80\xa6CjAn error that occurs when a starting configuration\xe2\x80\x99s \xe2\x80\xa60CfAlias for the associated type of <code>Div</code>: \xe2\x80\xa6BhFuture for the <code>read</code> method.AjReads bytes from a source.ClTrait used by the deserializer for iterating over input. \xe2\x80\xa6CnA trait for real number types that do not necessarily have \xe2\x80\xa6CgFuture returned by <code>Receiver::recv()</code> or \xe2\x80\xa6CbSequence to be concatenated with <code>self</code>CnThe dots in a tuple or slice pattern: <code>[0, 1, ..]</code>.BeHijri calendar, Saudi Arabia sightingBlProtocol corresponding to <code>SCTP</code>.CaA close notify message has been sent to the peer.CgThe number of bytes that a single value uses in memory.0CiThe number of bytes that a single small index uses in \xe2\x80\xa611Aj<code>Span</code> callsiteeSSLv3AkA salt for HKDF operations.FiA <strong>type operator</strong> that ensures that <code>Rhs</code> is the same as <code>Self</code>, \xe2\x80\xa6BhStream for the <code>scan</code> method.AoRepresents an EVP_Seal context.AbA Sec1 private keyBkSeed type, which is restricted to types \xe2\x80\xa60BhFuture for the <code>seek</code> method.n<code>;</code>BhFuture for the <code>send</code> method.=CdAn object which calculates a SHA1 hash of some data.AcSHA-1 hasher state.DcA <code>Sign</code> is a <code>BigInt</code>\xe2\x80\x99s composing element.DgA <code>Sink</code> is a value into which other values can be sent, \xe2\x80\xa6BlWriter for the <code>sink()</code> function.1CcAn async writer which will move data into the void.BlThe conversion source was of incorrect size.0000BhStream for the <code>skip</code> method.ClDon\xe2\x80\x99t unpark the thread and continue scanning the list \xe2\x80\xa6Eg<code>Skip</code> is an iterator that skips over the first <code>n</code> elements. \xe2\x80\xa6DkSkips missed ticks and tick on the next multiple of <code>period</code> \xe2\x80\xa6BmPre-allocated storage for a uniform data typeBbSome value of type <code>T</code>.00000000000BjA representation of a range in a haystack.CgA region of source code, along with macro expansion \xe2\x80\xa6CfA representation of a span reported by a regex engine.ClSpan represents the position information of a single AST \xe2\x80\xa6CnA handle representing a span, with the capability to enter \xe2\x80\xa60CmAlias for the associated type of <code>SquareRoot</code>: \xe2\x80\xa6n<code>*</code>BkA statement, usually ending in a semicolon.CkDon\xe2\x80\x99t unpark the thread and stop scanning the list of \xe2\x80\xa6BhAlias to make it easy to subtract 1: \xe2\x80\xa6CnAll pending output is flushed to the output buffer and the \xe2\x80\xa60CnFinish compressing the currently buffered data, and output \xe2\x80\xa6CmTry to flush all the current data and output an empty raw \xe2\x80\xa6De<code>TArr</code> is a type that acts as an array of types. It is \xe2\x80\xa6dtextgTLSv1.0CjA constant RawValue with the JSON value <code>true</code>.DbA <code>Buf</code> adapter which limits the bytes read from an \xe2\x80\xa6BhReader for the <code>take</code> method.BhStream for the <code>take</code> method.E`<code>Take</code> is an iterator that iterates over the first <code>n</code> \xe2\x80\xa61BnHijri calendar, tabular (intercalary years \xe2\x80\xa6ChUse a text presentation for emoji characters if possibleBhFuture for the <code>then</code> method.BhStream for the <code>then</code> method.Db<code>Service</code> returned by the <code>then</code> combinator.BoTraditional style ordering (such as in Spanish)CkA sequence of decimal digits is sorted at primary level \xe2\x80\xa6CeSpecification of communication semantics on a socket.CmA generic type parameter: <code>T: Into&lt;String&gt;</code>.CdA type predicate in a <code>where</code> clause: \xe2\x80\xa6AaA type alias: \xe2\x80\xa6DgA foreign type in an <code>extern</code> block: <code>type void</code>.CdAn associated type within the definition of a trait.BhAn associated type within an impl block.CaA type ascription pattern: <code>foo: f64</code>.A`A type argument.AnA particular type is returned.C`The possible types that a Rust value could have.Aa<code>type</code>CkA 128-bit unsigned integer stored in big-endian byte order.CkA 128-bit unsigned integer stored in little-endian byte \xe2\x80\xa6ClA 128-bit unsigned integer stored in network-endian byte \xe2\x80\xa6CkA 128-bit unsigned integer stored in native-endian byte \xe2\x80\xa6ChA 128-bit unsigned integer stored in a given byte order.Do<code>UInt</code> is defined recursively, where <code>B</code> is the least \xe2\x80\xa6CjDomain for Unix socket communication, corresponding to \xe2\x80\xa6DaA unary operator: <code>*</code>, <code>!</code>, <code>-</code>.BlNo fields, e.g. <code>struct Example;</code>CkUnit represents a single unit of haystack for DFA based \xe2\x80\xa6DaThe input contained a unit <code>()</code> that was not expected.0CfUnit struct or unit variant such as <code>None</code>.CgDetermines how to match future requests with cached \xe2\x80\xa6C`Combine single vectors into a multi-lane vector.ClA vector composed of two elements, which may be words or \xe2\x80\xa6CmA vector composed of four elements, which may be words or \xe2\x80\xa6AeThe \xe2\x80\x9cwarn\xe2\x80\x9d level.000dwoff1BoCorresponds to the <code>Warn</code> log level.CaA pattern that matches any value: <code>_</code>.BfSink for the <code>with</code> method.A`Word characters.Ai<code>[0-9A-Za-z_]</code>BlAn <code>X509</code> public key certificate.CkA Cow-like borrowed object \xe2\x80\x9cyoked\xe2\x80\x9d to its backing data.oThe zero value.0DbA constant <code>BigInt</code> with value 0, useful for static \xe2\x80\xa6DcA constant <code>BigUint</code> with value 0, useful for static \xe2\x80\xa6BbA constant <code>Ratio</code> 0/1.DcThe additive identity element of <code>Self</code>, <code>0</code>.AcRepresentation of 0AeThe zero index value.66oThe value zero.00000000000CkDefines an additive identity element for <code>Self</code>.EkA <strong>marker trait</strong> to designate that a type is zero. Only <code>B0</code>, \xe2\x80\xa6AnWrapped using the zlib format.BmBuild an ioctl number for an read-only ioctl.BnBuild an ioctl number for an write-only ioctl.oArccosine (f64)CjComputes the arccosine of a number. Return value is in \xe2\x80\xa60AdReturns the address.00CeAuthenticated Encryption with Associated Data (AEAD).CmAn unconditional epsilon transition to another NFA state. \xe2\x80\xa60ChA module with low-level architecture dependent routines.AiSets executable argument.AaThe message body.AfSet <code>args</code>.BoAdds multiple arguments to pass to the program.mArcsine (f64)ChComputes the arcsine of a number. Return value is in \xe2\x80\xa60BbDefines the format of certificatesBbThe alternate regular expressions.BfThe concatenation regular expressions.A`Arctangent (f64)CkComputes the arctangent of a number. Return value is in \xe2\x80\xa60AjHttp1 or Http2 connection.CeCreates a <code>AVec</code> containing the arguments.DkAlgorithms for the <code>x86_64</code> target using 256-bit vectors via \xe2\x80\xa6AkReturn early with an error.BlOptimize for the size of data being encoded.ClBinds a <code>DataMarker</code> to a provider supporting it.ChConvenience method to bind a new TCP listener to the \xe2\x80\xa6BlCreates a UDP socket from the given address.CgCreates a Unix datagram socket bound to the given path.DiCreates a new <code>UnixListener</code> bound to the specified socket \xe2\x80\xa6BkBinds this socket to the specified address.DfCreates a new <code>TcpListener</code>, which will be bound to the \xe2\x80\xa6BfBinds the socket to the given address.CmThis function will create a new UDP socket and attempt to \xe2\x80\xa6DdCreates a new <code>UnixDatagram</code> bound to the specified path.DdCreates a new <code>UnixListener</code> bound to the specified path.3AnGet the underlying bits value.DhDetermines the fewest bits necessary to express the <code>BigInt</code>,DkDetermines the fewest bits necessary to express the <code>BigUint</code>\xe2\x80\xa62222AlReturns the size of the key.BoReturns the number of bits used for the cipher.44444444CmThe underlying representation this set is exposed to make \xe2\x80\xa60C`Returns a reference to the associated HTTP body.Dh\xe2\x80\x9cConsumes\xe2\x80\x9d this builder, using the provided <code>body</code> to \xe2\x80\xa610BkStreaming bodies for Requests and ResponsesBeCompress and decompress data in bulk.CmTemporarily yields the mutex to a waiting thread if there \xe2\x80\xa60000DkTemporarily yields the <code>RwLock</code> to a waiting thread if there \xe2\x80\xa600AmThe quit byte that was found.0CiThe \xe2\x80\x9cquit\xe2\x80\x9d byte that was observed that caused the \xe2\x80\xa6DjIf this literal was written as a <code>\\x</code> hex escape, then this \xe2\x80\xa6CjThe character\xe2\x80\x99s byte value between this node and its \xe2\x80\xa6CkProcess the request and return the response asynchronously.CjCalls the given parser function to parse a syntax tree \xe2\x80\xa611BgCast <code>A</code> into <code>B</code>0DeConvert between two <code>DynamicDataMarker</code> types that are \xe2\x80\xa60BhCast from one machine scalar to another.EhCasts a <code>ZeroSlice&lt;T&gt;</code> to a compatible <code>ZeroSlice&lt;P&gt;</code>.BfCompute the cube root of the argument.DjReturns the truncated principal cube root of <code>self</code> \xe2\x80\x93 see \xe2\x80\xa60CkReturns the truncated principal cube root of an integer \xe2\x80\x9300B`Take the cubic root of a number.0jCeil (f64)AmRounds towards plus infinity.CkReturns the smallest integer greater than or equal to a \xe2\x80\xa600A`The certificate.CfCreates a new <code>PKey</code> containing a CMAC key.BlThe response code, such as <code>200</code>.CbReturns the raw OpenSSL error code for this error.CeInterface for processing OpenSSL configuration files.BbLower-level client connection API.AfServer connection API.AeConnection utilities.BnUtilities for improved cooperative scheduling.ChCreates a future which copies all the bytes from one \xe2\x80\xa6CeThis corresponds to <code>EVP_CIPHER_CTX_copy</code>.CmCopies the contents of one file to another. This function \xe2\x80\xa6CnAsynchronously copies the entire contents of a reader into \xe2\x80\xa6BnCreates a prepared dictionary for compression.BoCreate a prepared dictionary for decompression.BdStreaming compression functionality.BfStreaming decompression functionality.DmThe <em>core</em> part of the RNG, implementing the <code>generate</code> \xe2\x80\xa60BcThe cosine of <code>x</code> (f32).AgHyperbolic cosine (f64)AkHyperbolic cosine function.0CfEnable or disable the \xe2\x80\x9cCRLF mode\xe2\x80\x9d flag by default.C`Enable or disable the CRLF mode flag by default.DaEnable or disable the CRLF mode flag (<code>R</code>) by default.AhGet the next data frame.CgCreate a DATA frame with the provided <code>Buf</code>.0BmReturns additional data describing the error.CiReturns the field value of an <code>X509NameEntry</code>.AbDifference in daysBhTrain a dictionary from various sources.BaFind difference between two timesCjReturns a reference to the first exponent used for CRT \xe2\x80\xa6CkReturns a reference to the second exponent used for CRT \xe2\x80\xa6DeReturns whether the associated <code>Once</code> has successfully \xe2\x80\xa6CaDrops the object pointed to by the given pointer.CfDrops the future represented by the given fat pointer.00BkThis also wakes up the <code>Sender</code>.BmThis also wakes up the <code>Receiver</code>.BjSupport all versions of the DTLS protocol.CjRuns the passed-in function once for each bound field, \xe2\x80\xa60CgAdds or updates multiple environment variable mappings.BbComplementary error function (f64)AdError function (f32)BdRecords that a span has been exited.00ClExits this span, returning the underlying <code>Span</code>.111AiExponential, base 2 (f64)AnReturns <code>2^(self)</code>.0BbExponential, base <em>e</em> (f32)B`Absolute value (magnitude) (f64)ClReturns an HIR expression that can never match anything. \xe2\x80\xa6BhOptimize for the best speed of encoding.AiPositive difference (f64)CiA future that completes after the given item has been \xe2\x80\xa6BgThe source file containing the message.AeSet <code>file</code>CmReturns the name of the source file which encountered the \xe2\x80\xa6ClLookup method loads all the certificates or CRLs present \xe2\x80\xa6CkReturns the name of the source code file where the span \xe2\x80\xa60CmFill any type implementing <code>Fill</code> with random dataAjFill self with random data11BjFills <code>dest</code> with random bytes.DkFills <code>out</code> with the output of the HKDF-Expand operation for \xe2\x80\xa6ClReturns the location of the first match according to the \xe2\x80\xa6CnReturn the first occurrence of any of the patterns in this \xe2\x80\xa6CiReturns a reference to an entry in the table with the \xe2\x80\xa6CjReturn the first occurrence of the needle in the given \xe2\x80\xa6CmReturn the first occurrence of one of the needle bytes in \xe2\x80\xa60EgReturn the first occurrence of the <code>needle</code> in the <code>haystack</code> \xe2\x80\xa6CfReturn the first occurrence of the needle given to \xe2\x80\xa6DdReturns the first occurrence of <code>needle</code> in the given \xe2\x80\xa6333CaExecute a search using SSE2 vectors and routines.444CaExecute a search using AVX2 vectors and routines.CjReturns the index of the first occurrence of the given \xe2\x80\xa6ClReturns the index of the first occurrence of this needle \xe2\x80\xa6CjExecutes a leftmost search and returns the first match \xe2\x80\xa6CmExecutes an anchored leftmost forward search, and returns \xe2\x80\xa6CnReturns the start and end offset of the leftmost match. If \xe2\x80\xa60DjExecutes a leftmost forward search and returns a <code>Match</code> if \xe2\x80\xa6DkRun this prefilter on <code>haystack[span.start..end]</code> and return \xe2\x80\xa6DaReturn <code>true</code> if this is backed by a FIPS-approved \xe2\x80\xa6DkConvert <code>Either&lt;L, R&gt;</code> to <code>Either&lt;R, L&gt;</code>.0AkFloating multiply add (f32)CnReturn the greater of two arguments or, if either argument \xe2\x80\xa6CmReturn the lesser of two arguments or, if either argument \xe2\x80\xa6DhCalculate the remainder of <code>x / y</code>, the precise result of \xe2\x80\xa6CkExecute an accumulating asynchronous computation over a \xe2\x80\xa60CjFolds (or reduces) a sequence of data into a single value.CkParallel fold is similar to sequential fold except that theClSyntax tree traversal to transform the nodes of an owned \xe2\x80\xa6CjRuns the passed-in function once for each bound field, \xe2\x80\xa60CmForks a parse stream so that parsing tokens out of either \xe2\x80\xa6AoReturns the argument unchanged.000000000000000000000000000000000000000000000000000000000CnCreate a new <code>ArrayString</code> from a <code>str</code>.1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111BhConvert self into <code>BytesMut</code>.222222222222222222ClReturns a new atomic pointer pointing to <code>owned</code>.3CjReturns a new atomic pointer pointing to <code>raw</code>.CjReturns a new atomic pointer pointing to <code>ptr</code>.CgReturns a new owned pointer pointing to <code>b</code>.66CcReturns a new pointer pointing to <code>raw</code>.77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777CkConverts mutable slice to a mutable generic array referenceCmConverts slice to a generic array reference with inferred \xe2\x80\xa699999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999hExamples:::::::::::::::0::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::ClConverts a <code>RawFd</code> to a <code>TcpListener</code>.;CjConverts a <code>RawFd</code> to a <code>TcpStream</code>.<CjConverts a <code>RawFd</code> to a <code>UdpSocket</code>.==============================CmCreates a number from another value that can be converted \xe2\x80\xa6>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>CdConstruct the <code>Aad</code> from the given bytes.?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????CdConvert <code>()</code> to <code>Value::Null</code>.CkConvert copy-on-write string to <code>Value::String</code>.CcConvert string slice to <code>Value::String</code>.CjConvert <code>String</code> to <code>Value::String</code>.CjConvert <code>Number</code> to <code>Value::Number</code>.AoReturns the argument unchanged.CmConvert map (with string keys) to <code>Value::Object</code>.BlConvert boolean to <code>Value::Bool</code>.DjConvert 64-bit floating point number to <code>Value::Number</code>, or \xe2\x80\xa6DjConvert 32-bit floating point number to <code>Value::Number</code>, or \xe2\x80\xa6ChConvert a <code>Vec</code> to <code>Value::Array</code>.BmConvert a slice to <code>Value::Array</code>.66666666666666666666666666666666666666666666666CkThe caller must ensure <code>S</code> is actually a socket.77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777DjConstruct a new <code>Input</code> for the given input <code>bytes</code>.888888888888888888888888888888888888888888888888888888888888888888888888888888EcInfallibly extracts the <code>SizeError</code> from this <code>CastError</code> \xe2\x80\xa699CeInfallibly discards the alignment error from this \xe2\x80\xa6:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::DiHint whether this <code>Consumer</code> would like to stop processing \xe2\x80\xa6DgHint whether this <code>Folder</code> would like to stop processing \xe2\x80\xa6BlCreate a full set of look-around assertions.0DhFuse a future such that <code>poll</code> will never again be called \xe2\x80\xa60DfFuse a stream such that <code>poll_next</code> will never again be \xe2\x80\xa60CjMark the state as idle, if the Taker currently is wanting.BfRe-allocate to set the capacity to \xe2\x80\xa6BhComputes the CRC32 hash of a byte slice.BjMessage digest (hash) computation support.EbComputes the hash of the <code>data</code> with the non-XOF hasher <code>t</code>.BkFeeds this value into <code>Adler32</code>.DiCreates a new <code>Builder</code> initialized with a HEAD method and \xe2\x80\xa6BkSets that this <code>Kind</code> is a hint.CfHMAC-based Extract-and-Expand Key Derivation Function.CgCreates a new <code>PKey</code> containing an HMAC key.AnHMAC is specified in RFC 2104.BlGet the host of this <code>Authority</code>.BfGet the host of this <code>Uri</code>.BnA general purpose library of common HTTP typesBkSet the target proxy for HTTP destinations.BaLogs a message at the info level.BfConstructs an event at the info level.BiInitializes a with the given initializer.DeAllocates <code>value</code> on the heap and returns a new atomic \xe2\x80\xa6DdAllocates <code>value</code> on the heap and returns a new owned \xe2\x80\xa6BlSet the current state to <code>Start</code>.ChInitializes this context with the given certificate, \xe2\x80\xa6CiInitializes the context with the given compression level.CoInitializes an existing <code>DStream</code> for decompression.BaCalls <code>U::from(self)</code>.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000CgReturns a reference to the coefficient used for CRT \xe2\x80\xa6CfYield the bits of a source flags value in a set of \xe2\x80\xa6BfYield a set of contained flags values.0BfBorrow the inner value as an iterator.EfConverts an <code>Iterator</code> into a <code>Stream</code> which is always ready \xe2\x80\xa6CmReturns an iterator that allows inspecting each stream in \xe2\x80\xa6CmReturns an iterator that allows inspecting each future in \xe2\x80\xa6Cb<code>GenericArray</code> iterator implementation.CiAn iterator visiting all key-value pairs in arbitrary \xe2\x80\xa6CmAn iterator visiting all elements in arbitrary order. The \xe2\x80\xa60BiAn iterator visiting all key-value pairs.CkReturns an iterator visiting all values associated with \xe2\x80\xa60DiReturns a new <code>Char16TrieIterator</code> backed by borrowed data \xe2\x80\xa6C`Produce an ordered iterator over key-value pairsBcGets an iterator over the elements.CjReturn an iterator over the key-value pairs of the map \xe2\x80\xa6CnReturn an iterator over the key-value pairs of the map, in \xe2\x80\xa6CdReturn an iterator over the values of the set slice.CkReturn an iterator over the values of the set, in their \xe2\x80\xa65BmIterate through all supported logging levels.BoIterate through all supported filtering levels.CjReturns an iterator over all occurrences of the needle \xe2\x80\xa6CjReturns an iterator over all occurrences of one of the \xe2\x80\xa60111111CgReturns an iterator over the <code>Event</code> values.BfYield a set of contained flags values.00000000000DcIterate over the indices as a sequence of <code>usize</code> valuesCaTraits for writing parallel programs using an \xe2\x80\xa6BfBorrow the inner value as an iterator.ClReturns an iterator over all pattern identifiers in this \xe2\x80\xa6CiGeneric helpers for iteration of matches from a regex \xe2\x80\xa6CnReturns an iterator over all of the look-around assertions \xe2\x80\xa6ClReturns an iterator over all equivalence classes in this \xe2\x80\xa6CmReturns an iterator of possible spans for every capturing \xe2\x80\xa6CaReturn an iterator over all ranges in this class.03BmGets an iterator over the entries of the map.BaReturn an iterator over the slab.DfGet an iterator over the borrowed <code>Field</code> items in this \xe2\x80\xa6CjReturns an iterator over borrowed syntax tree nodes of \xe2\x80\xa6DoReturns an iterator over the <code>Field</code>s in this <code>FieldSet</code>.0CgIterates over the pixels in the plane, skipping the \xe2\x80\xa6CiReturn an iterator over all possible RevocationReason \xe2\x80\xa6BoObtain an iterator over this slice\xe2\x80\x99s elementsBcGets an iterator over the elements.Algithub\xe2\x80\x82crates-io\xe2\x80\x82docs-rsCkCalculates the Jaro similarity between two strings. The \xe2\x80\xa6CfWaits for the thread to finish and returns its result.ClPolls multiple futures simultaneously, returning a tuple \xe2\x80\xa60CmJoins the result of two futures, waiting for them both to \xe2\x80\xa6DhCreate a new span encompassing <code>self</code> and <code>other</code>.CcReturns a span covering the entire delimited group.DfTakes two closures and <em>potentially</em> runs them in parallel. \xe2\x80\xa6EeExecute <code>oper_a</code> and <code>oper_b</code> in the thread pool and return \xe2\x80\xa610DnWaits on multiple concurrent branches, returning when <strong>all</strong> \xe2\x80\xa6EhJoin two values implementing <code>AsyncRead</code> and <code>AsyncWrite</code> into \xe2\x80\xa6CoConstruct a <code>serde_json::Value</code> from a JSON literal.CiAn iterator visiting all keys in arbitrary order. The \xe2\x80\xa6AnAn iterator visiting all keys.CbReturn an iterator over the keys of the map slice.CkReturn an iterator over the keys of the map, in their orderBeProduce an ordered iterator over keysBjGets an iterator over the keys of the map.AiForces the child to exit.CjReturns the kind of the Aho-Corasick automaton used by \xe2\x80\xa6BoChoose the type of underlying automaton to use.CaReturns a reference to the underlying error kind.AlBroad category of the error.1AnReturn the type of this error.AiThe kind of this literal.AgThe kind of Perl class.AhThe kind of ASCII class.AjThe kind of Unicode class.CkThe type of this set. A set is either a normal union of \xe2\x80\xa6AoThe type of this set operation.ClThe assertion kind, e.g., <code>\\b</code> or <code>^</code>.AfThe type of operation.AgThe kind of this group.AfThe kind of this item.:BoReturns a reference to the underlying HIR kind.DhSet the kind of literal sequence to extract from an <code>Hir</code> \xe2\x80\xa6DbThe <code>LanguageIdentifier</code> specified with this locale \xe2\x80\xa6AlGet the last key-value pair.AkGet the last key-value pairAcGet the last value.AbGet the last valueDiGet the highest-rank key/value pair from the <code>LiteMap</code>, if \xe2\x80\xa6BjBorrows the last element in this sequence.CjGets the last element. Returns <code>None</code> if empty.CkCreates a new future that allows delayed execution of a \xe2\x80\xa6CgA lazily initialized value for safe sharing between \xe2\x80\xa6ClLeaks the mutex guard and returns a mutable reference to \xe2\x80\xa6ElConvert the left side of <code>Either&lt;L, R&gt;</code> to an <code>Option&lt;L&gt;</code>.0Chlibc - Raw FFI bindings to platforms\xe2\x80\x99 system librariesAalibm in pure RustB`The line containing the message.AeSet <code>line</code>CmReturns the line in the source file which encountered the \xe2\x80\xa6BlThe line number, starting at <code>1</code>.Bcline that contains the syntax errorCfOne-based line number at which the error was detected.CmReturns the line number in the source code file where the \xe2\x80\xa60CdLoads a <code>Shared</code> from the atomic pointer.BcLoads a value from the atomic cell.CbQuery the provider for data, returning the result.ClLoads a new provider into the specified library context, \xe2\x80\xa6BkFutures-powered synchronization primitives.B`Acquire the lock asynchronously.CmAcquires this mutex, blocking the current thread until it \xe2\x80\xa6CmAcquires a mutex, blocking the current thread until it is \xe2\x80\xa6CkAcquires this mutex, blocking if it\xe2\x80\x99s held by another \xe2\x80\xa6CkAcquires a reentrant mutex, blocking the current thread \xe2\x80\xa6CmLocks this mutex, causing the current task to yield until \xe2\x80\xa6BmThe base 2 logarithm of <code>x</code> (f64).BkReturns the base 2 logarithm of the number.0BnThe natural logarithm of <code>x</code> (f32).CkThe look-around assertion that must be satisfied before \xe2\x80\xa6CkTypes and routines for working with look-around assertions.BoCreates a look-around assertion HIR expression.CgMarks async function to be executed by the selected \xe2\x80\xa60CmTrait aliases for Services that produce specific types of \xe2\x80\xa6EbThis method can be used to cast away <code>Self&lt;&#39;a&gt;</code>\xe2\x80\x99s lifetime.DbGets the value for the <code>SO_MARK</code> option on this socket.CnProvides a regex matcher that composes several other regex \xe2\x80\xa6CmFacility for interpreting structured content inside of an \xe2\x80\xa6dMimeAlMock random number generatorCiif this brotli file is generic, font or specifically textBlThe anchored mode given that is unsupported.00BmSets the mode to create new directories with.ChSets the mode bits that a new file will be created with.CnA multi-producer, single-consumer queue for sending values \xe2\x80\xa60DbLike <code>new</code>, but panics if the given value is not valid.CjCreate a new match from a pattern ID and a byte offset \xe2\x80\xa61ChCreate a new half match from a pattern ID and a byte \xe2\x80\xa61DkLike <code>SmallIndex::new</code>, but panics if the given index is not \xe2\x80\xa633AjGet the name of this flag.BaSets the name for the new thread.AmThe name portion of a header.DgThe <code>friendlyName</code> used for the certificate and private key.AoReturns the name of the cipher.BiGets the string that was specified by \xe2\x80\xa60AaThe capture name.BgThe property name (which may be empty).1BfThe name of the capture, if it exists.AmReturns the name of the span.CdReturns a string representing the name of the field.01DiCreates a <code>TokenBuffer</code> containing all the tokens from the \xe2\x80\xa6CjCreates a future that resolves to the next item in the \xe2\x80\xa60ClTraverses the trie from the current state for this input \xe2\x80\xa6BmThe identifier of the state to transition to.CnThe state to transition to if the look-around assertion is \xe2\x80\xa6BlThe state to transition to, unconditionally.ChNo compression is to be performed, this may actually \xe2\x80\xa6DcReturns a new <code>Dispatch</code> that discards events and spans.CkConstructs a new span that is <em>completely disabled</em>.1DdConstructs a new <code>Current</code> that indicates the current \xe2\x80\xa6BbReturns a new null atomic pointer.AkReturns a new null pointer.BeCreates a stream of a single element.ChCreates a parallel iterator that produces an element \xe2\x80\xa6CkReturns a span for the opening punctuation of the group \xe2\x80\xa6BjAttempts to open a file in read-only mode.EbOpens a file at <code>path</code> with the options specified by <code>self</code>.CiReturns the pair of offsets (into the needle) used to \xe2\x80\xa600BlCreate an unnamed pair of connected sockets.BmCreates an unnamed pair of connected sockets.CiCreates a pair of sockets which are connected to each \xe2\x80\xa611CeBlocks the current thread until the token is made \xe2\x80\xa6CmParks the current thread in the queue associated with the \xe2\x80\xa6AjReturns the path componentBfGet the path of this <code>Uri</code>.CaThe request path, such as <code>/about-us</code>.CjReturns the path that identifies the interpretation of \xe2\x80\xa6CgReturns the path that begins this structured meta item.FdThe <code>Foo&lt;&amp;&#39;a T&gt;</code> in <code>for&lt;&#39;a&gt; Foo&lt;&amp;&#39;a T&gt;</code>CeReturns the full path to the file that this entry \xe2\x80\xa6EdReturns <code>Some</code> containing a reference to this <code>Shared</code>\xe2\x80\x99s \xe2\x80\xa6CmProduces a future which retrieves a reference to the next \xe2\x80\xa6CjReceives data on the socket from the remote address to \xe2\x80\xa6CkReceives data from the socket, without removing it from \xe2\x80\xa61CmReturns whether the next token in the parse stream is one \xe2\x80\xa6ClLooks at the next token in the parse stream to determine \xe2\x80\xa603CiReceives a single datagram from the connected address \xe2\x80\xa644DgReturns <code>true</code> if there is at least one more byte in the \xe2\x80\xa6BmConvert the wrapper type into the inner type.0CiSend a PING frame and wait for the peer to send the pong.jUnix pipe.A`Unix pipe types.BbCreates a new anonymous Unix pipe.BkRepresents the <code>SIGPIPE</code> signal.AnPublic/private key processing.AmThe signature\xe2\x80\x99s public-key.A`The private key.CmA macro which returns the result of polling a future once \xe2\x80\xa60AiWait for readiness eventsBgPoll the future stored inside this box.0AjA thread safe memory pool.CaGet the port part of this <code>Authority</code>.BkGet the port part of this <code>Uri</code>.DiCreates a new <code>Builder</code> initialized with a POST method and \xe2\x80\xa6ClReturns <code>x</code> to the power of <code>y</code> (f32).BiRaise a number to a floating point power.BfRaise a number to a real number power.BcRaise a number to an integer power.00ChThis function isn\xe2\x80\x99t used in this crate, but may be \xe2\x80\xa6CbPush the given value to the end of the vector, \xe2\x80\xa6CcPush <code>element</code> to the end of the vector.BmAdds the given char to the end of the string.AmPushes a task into the queue.0B`Add one error to the collection.AmPush a future into the queue.AkPush a stream into the set.AkPush a future into the set.BiPushes a value onto the top of the stack.AnPush a new item in this union.AlAdd a new range to this set.0BkPush a literal to the end of this sequence.AmAppend an item to the vector.CnAppends a syntax tree node onto the end of this punctuated \xe2\x80\xa6Ai<code>q**-1 mod p</code>.AgQUIC Header Protection.DjCreate a new \xe2\x80\x9cquit\xe2\x80\x9d error. The given <code>byte</code> corresponds \xe2\x80\xa6BaAdd a \xe2\x80\x9cquit\xe2\x80\x9d byte to the DFA.BfAdd a \xe2\x80\x9cquit\xe2\x80\x9d byte to the lazy DFA.BkRepresents the <code>SIGQUIT</code> signal.CmThread-safe, non-blocking, \xe2\x80\x9cfirst one wins\xe2\x80\x9d flavor of \xe2\x80\xa6BnUtilities for secure random number generation.DkGenerates a cryptographically strong pseudo-random <code>BigNum</code>, \xe2\x80\xa6BfUtilities for random number generationBnCryptographic pseudo-random number generation.ClReturn the heuristic frequency rank of the given byte. A \xe2\x80\xa6BiReturns the \xe2\x80\x9crank\xe2\x80\x9d of the given byte.DhImplementations of <code>io::Read</code> to transparently decode base64.BeDecode input from the wrapped reader.CmThis variant of read will return Ok(number of bytes read) \xe2\x80\xa60CnLocks with shared read access, blocking the current thread \xe2\x80\xa6DhRead output into the <code>buffer</code>. Can be called an unlimited \xe2\x80\xa6DiTypes which operate over <code>Read</code> streams, both encoders and \xe2\x80\xa6CjConsume this builder, creating a reader encoder in the \xe2\x80\xa6DhTries to read some bytes directly into the given <code>buf</code> in \xe2\x80\xa6DhLocks this <code>RwLock</code> with shared read access, blocking the \xe2\x80\xa6AeReader-based hashing.DgLocks this <code>RwLock</code> with shared read access, causing the \xe2\x80\xa6ChReads the entire contents of a file into a bytes vector.B`Sets the option for read access.ChPulls some bytes from this source into the specified \xe2\x80\xa60AoReads a copy of <code>T</code>.DiImplement pull-based <code>Read</code> trait for both compressing and \xe2\x80\xa6CkWaits for a message from the channel. If the channel is \xe2\x80\xa60CgReceives data from the socket previously bound with \xe2\x80\xa6AnReceives data from the socket.CjReceives data on the socket from the remote address to \xe2\x80\xa6BjReceives the next value for this receiver.00CmReceives a single datagram message on the socket from the \xe2\x80\xa63BlReceives the next signal notification event.mFeature FlagsCnSignature verification algorithm implementations using the \xe2\x80\xa6DgRound <code>x</code> to the nearest integer, breaking ties toward even.BeRandom number generators and adaptersDjCombinator similar to <code>StreamExt::fold</code> that holds internal \xe2\x80\xa60AfDifference in seconds.CkCreates a future which will seek an IO object, and then \xe2\x80\xa600C`Completes this oneshot with a successful result.CiA future that completes after the given item has been \xe2\x80\xa6ClSends data on the socket to the address previously bound \xe2\x80\xa6C`Sends data on the socket to the socket\xe2\x80\x99s peer.BmSends data on the socket to a connected peer.BoSends a value, waiting until there is capacity.BjSends a value using the reserved capacity.0DkAttempts to send a message on this <code>UnboundedSender</code> without \xe2\x80\xa6DiAttempts to send a value to all active <code>Receiver</code> handles, \xe2\x80\xa6CkSends a new value via the channel, notifying all receivers.CjAttempts to send a value on this channel, returning it \xe2\x80\xa6CkSends data on the socket to the remote address that the \xe2\x80\xa68BdComputes the SHA1 hash of some data.ClPure Rust implementation of the SHA-1 cryptographic hash \xe2\x80\xa6DcReturns the sign of the <code>BigInt</code> as a <code>Sign</code>.AcMessage signatures.E`Given a signing cert <code>signcert</code>, private key <code>pkey</code>, a \xe2\x80\xa6DjComputes a digital signature of the hash value <code>data</code> using \xe2\x80\xa6CoCreates and returns a PKCS#7 <code>signedData</code> structure.BhSigns the contents of <code>data</code>.ClWrites the signature into the provided buffer, returning \xe2\x80\xa6BiSigns the certificate with a private key.BeSign the request using a private key.EdCalculates the HMAC of <code>data</code> using the key <code>key</code> in one step.CnFinalizes the HMAC calculation and returns the HMAC value. \xe2\x80\xa6EeComputes the signature of <code>msg</code> and writes it into <code>signature</code>.CfReturns the signature of the message <code>msg</code>.DjReturns the signature of the <code>message</code> using a random nonce \xe2\x80\xa6BaThe sine of <code>x</code> (f32).BlThe hyperbolic sine of <code>x</code> (f64).AiHyperbolic sine function.0CkCreates an instance of a writer which will successfully \xe2\x80\xa6AcAsynchronous sinks.CeCreates an instance of an async writer which will \xe2\x80\xa6BlReturn size of the internal buffer in bytes.BiReturns the number of elements of the \xe2\x80\xa6CcReturns the number of elements in this set (its \xe2\x80\xa6B`The size of the digest in bytes.DiReturns the maximum size of the signature output by <code>self</code> \xe2\x80\xa6BhReturns the size of the digest in bytes.ClReturns the size of the message digest, i.e. the size of \xe2\x80\xa6CaReturns the maximum size of a signature in bytes.BiReturns the size of the modulus in bytes.BoReturns the number of items the array can hold.Ai&lt; size of input bufferAj&lt; size of output buffer10DkCreates a new stream which skips <code>n</code> items of the underlying \xe2\x80\xa60DaCreates an iterator that skips the first <code>n</code> elements.BjSkips <code>num_bytes</code> of the input.BnPre-allocated storage for a uniform data type.CnThe slot index for this capture. Every capturing group has \xe2\x80\xa6ChReturns the starting slot corresponding to the given \xe2\x80\xa6CbSort the set\xe2\x80\x99s values by their default ordering.CbSorts this sequence of literals lexicographically.AmSet the span for this search.B`Returns the span for this match.AiGet a span for the error.DiGet the span of the flag, or <code>Span::call_site</code> if the flag \xe2\x80\xa6CfGet the location of this <code>Ident</code> in source.CgGet the source code location referenced by this struct.CfReturns the end of the initial substring where the \xe2\x80\xa6DfReturns the span of this tree, delegating to the <code>span</code> \xe2\x80\xa6CmReturns the span for the delimiters of this token stream, \xe2\x80\xa6C`Returns the span for this punctuation character.BlReturns the span of this <code>Ident</code>.BkReturns the span encompassing this literal.CeSpan associated with this <code>IdentFragment</code>.0<;BmReturn the span at which this error occurred.BmReturn the span of this abstract syntax tree.BlReturn the span of this character class set.CaReturn the span of this character class set item.DhThe span of this comment, including the beginning <code>#</code> and \xe2\x80\xa6AmThe span of this alternation.AoThe span of this concatenation.AiThe span of this literal.AgThe span of this class.000AgThe span of this range.DjThe span of the items in this operation. e.g., the <code>a-z0-9</code> \xe2\x80\xa6DdThe span of this operation. e.g., the <code>a-z--[h-p]</code> in \xe2\x80\xa6AkThe span of this assertion.AkThe span of this operation.EhThe span of this operator. This includes things like <code>+</code>, <code>*?</code> \xe2\x80\xa6AgThe span of this group.AnThe span of this capture name.CcThe span of these flags, including the grouping \xe2\x80\xa6B`The span of this group of flags.AfThe span of this item.BmReturn the span at which this error occurred.BaThe source location of the error.BlReturns the span of this <code>Ident</code>.EhReturns the <code>Span</code> of the current token, or <code>Span::call_site()</code>\xe2\x80\xa6DkReturns the <code>Span</code> of the next token in the parse stream, or \xe2\x80\xa6DfReturns a <code>Span</code> covering the complete contents of this \xe2\x80\xa6AfConstructs a new span.D`Borrows the <code>Span</code> that this type is instrumented by.CjSpans represent periods of time in which a program was \xe2\x80\xa6CiSpans represent periods of time in the execution of a \xe2\x80\xa6AnBacks off in a lock-free loop.CaSpins until the sleep threshold has been reached.BhThe square root of <code>x</code> (f64).DhReturns the truncated principal square root of <code>self</code> \xe2\x80\x93 \xe2\x80\xa60CmReturns the truncated principal square root of an integer \xe2\x80\xa600BaTake the square root of a number.0DkAlgorithms for the <code>x86_64</code> target using 128-bit vectors via \xe2\x80\xa6CgSpeculatively parses tokens from this parse stream, \xe2\x80\xa6CmSteps the cursor one character into the trie based on the \xe2\x80\xa6BhSteps the cursor one byte into the trie.CiReturns a slice of this kind\xe2\x80\x99s sub-expressions, if any.EgStores a <code>Shared</code> or <code>Owned</code> pointer into the atomic pointer, \xe2\x80\xa6DiStores <code>val</code> into the atomic cell and returns the previous \xe2\x80\xa6CbHigh level interface to certain symmetric ciphers.BbThread synchronization primitives.CgThread-safe, blocking version of <code>OnceCell</code>.CfSynchronization primitives for use in asynchronous \xe2\x80\xa6AjSynchronization primitivesCkReturns the ArrayVec, replacing the original with a new \xe2\x80\xa6EdReturns the last <code>Waker</code> passed to <code>register</code>, so that the \xe2\x80\xa6DgCreates an adaptor which will read at most <code>limit</code> bytes \xe2\x80\xa60BoTakes the value of the atomic cell, leaving \xe2\x80\xa6DkCreates an AsyncRead adapter which will read at most <code>limit</code> \xe2\x80\xa63DjCreates a new stream of at most <code>n</code> items of the underlying \xe2\x80\xa60CmRemoves and returns the value in the set, if any, that is \xe2\x80\xa640DkTakes the value out of this <code>OnceCell</code>, moving it back to an \xe2\x80\xa60DbCreates an iterator that yields the first <code>n</code> elements.DhTakes only <code>n</code> repeats of the element, similar to the generalEeTakes the value out of the <code>Value</code>, leaving a <code>Null</code> in its \xe2\x80\xa6CjTakes ownership of the current value, leaving the cell \xe2\x80\xa6DkReturns a new <code>ReadBuf</code> comprised of the unfilled section up \xe2\x80\xa6DhCreates an adaptor which reads at most <code>limit</code> bytes from it.0BdThe tangent of <code>x</code> (f32).BoThe hyperbolic tangent of <code>x</code> (f64).AlHyperbolic tangent function.0CmCreate a new type-level array. Only usable on Rust 1.13.0 \xe2\x80\xa6AbTask notification.AmTools for working with tasks.AkAsynchronous green-threads.ClMarks async function to be executed by runtime, suitable \xe2\x80\xa60CnChain on a computation for when a future finished, passing \xe2\x80\xa60CfComputes from this stream\xe2\x80\x99s items new items of a \xe2\x80\xa60CnComposes an asynchronous function <em>after</em> this service.0CeApply an asynchronous function after the service, \xe2\x80\xa6ClCompletes when the next instant in the interval has been \xe2\x80\xa6CmReturns the time at which the session was established, in \xe2\x80\xa6AlUtilities for tracking time.AdThe validation time.00AgTrie for decomposition.CgTrie for the supplementary non-recursive decompositionsDkNote: The <code>ScriptWithExt</code> values in this array will assume a \xe2\x80\xa6EeReturns the <code>Type</code> of this socket by checking the <code>SO_TYPE</code> \xe2\x80\xa6DfCompare the absolute values of <code>self</code> and <code>oth</code>.AmType-level unsigned integers.AeUnix only extensions.EcConstructs a <code>SockAddr</code> with the family <code>AF_UNIX</code> and the \xe2\x80\xa6AlUnix specific network types.BhUnix-specific types for signal handling.CnAsynchronous IO structures specific to Unix-like operating \xe2\x80\xa6CbWhether to enable UTF-8 mode during search or not.CnWhen disabled, the builder will permit the construction of \xe2\x80\xa6CjConverts ranges of Unicode scalar values to equivalent \xe2\x80\xa6CnWhen disabled, translation will permit the construction of \xe2\x80\xa60BdUtility types for attribute parsing.CmA collection of modules that provide APIs that are useful \xe2\x80\xa6AnUtilities for combining layersCjVarious utility types and functions that are generally \xe2\x80\xa6CmThis module contains additional utility types for working \xe2\x80\xa6CmDrops this reference and waits until all other references \xe2\x80\xa6ClGets the reference to the underlying value, blocking the \xe2\x80\xa6CkBlocks the current thread until this condition variable \xe2\x80\xa6AmWaits until the value is set.ChDoes not resolve until all tasks have rendezvoused here.CiWaits for the child to exit completely, returning the \xe2\x80\xa6CfBlocks the current thread until initialization has \xe2\x80\xa6EgCalls <code>wake</code> on the last <code>Waker</code> passed to <code>register</code>.CgIndicates that the associated task is ready to make \xe2\x80\xa6001DfWake up the <code>Poll</code> associated with this <code>Waker</code>.ClA Futures channel-like utility to signal when a value is \xe2\x80\xa6EdReturns a <code>Future</code> that fulfills when the <code>Taker</code> has done \xe2\x80\xa6ChSignal to the <code>Giver</code> that a value is wanted.BaLogs a message at the warn level.BfConstructs an event at the warn level.CmTypes and routines that support the wire format of finite \xe2\x80\xa6CbComposes a function <em>in front of</em> the sink.FeReturns a new repetition with the same <code>min</code>, <code>max</code> and <code>greedy</code> \xe2\x80\xa6CiAccesses the current task-local and runs the provided \xe2\x80\xa6BmConvert the inner type into the wrapper type.0CbThe standard defining the format of public key \xe2\x80\xa6AkDecimator along the X axis.BfNumber of padding pixels on the right.AkDecimator along the Y axis.EaThis crate provides <code>Yoke&lt;Y, C&gt;</code>, which allows one to \xe2\x80\x9cyoke\xe2\x80\xa6BgNumber of padding pixels on the bottom.BnReturns the additive identity, <code>0</code>.DkReturns the additive identity element of <code>Self</code>, <code>0</code>.BhOverwrites <code>self</code> with zeros.Algithub\xe2\x80\x82crates-io\xe2\x80\x82docs-rsBaRust binding to the zstd library.AiThe alignment of pointer.BoLists the set of methods support by a resource.BeThe terminating type for type arrays.eaudioBkAbort the operation without doing anything.CnTreat unknown revocation status permissively, acting as if \xe2\x80\xa6EdCharacters with the <code>Alphabetic</code> or <code>Decimal_Number</code> property.Ah<code>[0-9A-Za-z]</code>FgE.g. <code>+</code> is <code>Alone</code> in <code>+ =</code>, <code>+ident</code> or <code>+()</code>.Ae<code>[A-Za-z]</code>Ac<code>&amp;=</code>AhRepresents a JSON array.0DhTypes that can be used as the backing store for a <code>SmallVec</code>.CfA slice literal expression: <code>[a, b, c, d]</code>.BmA fixed size array type: <code>[T; n]</code>.CgA trait for any type that has a 1:1 mapping with an \xe2\x80\xa6Ah<code>[\\x00-\\x7F]</code>EaAn ASCII character class, e.g., <code>[:alnum:]</code> or <code>[:punct:]</code>.BkAn async block: <code>async { ... }</code>.Ab<code>async</code>BlAn await expression: <code>fut.await</code>.Ab<code>await</code>ebasicjBaked data0DgA binary operator: <code>+</code>, <code>+=</code>, <code>&amp;</code>.BhThe <code>|</code> operator (bitwise or)B`Horizontal whitespace charactersAb<code>[ \\t]</code>CaBlock on which <code>BlockBuffer</code> operates.CoBlock on which <code>BlockSizeUser</code> implementors operate.0A`Not implemented.BfA blocked scope: <code>{ ... }</code>.BjA braced block containing Rust statements.Ad<code>{ ... }</code>Ao<code>{</code>\xe2\x80\xa6<code>}</code>DiA <code>break</code>, with an optional label to break and an optional \xe2\x80\xa6Ab<code>break</code>BjTicks as fast as possible until caught up.CiA cheaply cloneable and sliceable chunk of contiguous \xe2\x80\xa60BlParallel iterator over the bytes of a stringCkA set of characters represented by arbitrary bytes (one \xe2\x80\xa6EkThe input contained a <code>&amp;[u8]</code> or <code>Vec&lt;u8&gt;</code> that was not \xe2\x80\xa60AgCompression dictionary.0FhThe <code>crypt(3)</code> alphabet (with <code>.</code> and <code>/</code> as the <em>first</em> two \xe2\x80\xa6oThe raw C type.000ClAn error that occurs when cache inefficiency has dropped \xe2\x80\xa6CjRepresents mutable scratch space used by regex engines \xe2\x80\xa6BlA cache represents a partially computed DFA.CgA cache represents a partially computed forward and \xe2\x80\xa6DeA cache represents mutable state that a one-pass <code>DFA</code> \xe2\x80\xa6DhA cache represents mutable state that a <code>PikeVM</code> requires \xe2\x80\xa6DkA cache represents mutable state that a <code>BoundedBacktracker</code> \xe2\x80\xa6n<code>^</code>BoUppercase, lowercase, and titlecase characters.BeIterator of a chain of source errors.BkA <code>Chain</code> sequences two buffers.BiReader for the <code>chain</code> method.BiStream for the <code>chain</code> method.Ek<code>Chain</code> is an iterator that joins <code>b</code> after <code>a</code> in one \xe2\x80\xa61ClCheck the revocation status of the end entity (leaf) and \xe2\x80\xa6CaParallel iterator over the characters of a stringCkRepresentation of a child process spawned onto an event \xe2\x80\xa6BnHijri calendar, tabular (intercalary years \xe2\x80\xa6CdA single character class that matches any of the \xe2\x80\xa6CmThe high-level intermediate representation of a character \xe2\x80\xa6BiFuture for the <code>close</code> method.0BjRepresents Bidi_Paired_Bracket_Type=Close.Al<code>[\\x00-\\x1F\\x7F]</code>CkA property set to a specific value using a colon, e.g., \xe2\x80\xa6n<code>:</code>n<code>,</code>BjA const block: <code>const { ... }</code>.ClA const generic parameter: <code>const LENGTH: usize</code>.CeA constant item: <code>const MAX: u16 = 65535</code>.ChAn associated constant within the definition of a trait.BlAn associated constant within an impl block.4BnA const expression. Must be inside of a block.Ab<code>const</code>BiFuture for the <code>count</code> method.Ab<code>crate</code>kMonochrome.BlBoth vertically and horizontally subsampled.AhHorizontally subsampled.oNot subsampled.BiStream for the <code>cycle</code> method.BdA digested decompression dictionary.0AfThe \xe2\x80\x9cdebug\xe2\x80\x9d level.000BnType corresponding to <code>SOCK_DGRAM</code>.hDTLSv1.0AkTraditional Korean calendar3C`Corresponds to the <code>Debug</code> log level.EdTick at multiples of <code>period</code> from when <code>tick</code> was called, \xe2\x80\xa6CcA dense representation of a state with multiple \xe2\x80\xa6BmThe <code>*</code> operator for dereferencingA`Decimal numbers.Ab<code>[0-9]</code>BnA draining iterator for <code>ArrayVec</code>.BiSink for the <code>drain</code> function.DeA draining iterator over the entries of a <code>HashMap</code> in \xe2\x80\xa6CmA draining iterator over the items of a <code>HashSet</code>.CoA draining iterator over the items of a <code>HashTable</code>.BlA drain iterator for <code>HeaderMap</code>.DaA draining iterator over the entries of an <code>IndexMap</code>.CoA draining iterator over the items of an <code>IndexSet</code>.CjDraining parallel iterator that moves a range out of a \xe2\x80\xa6ClDraining parallel iterator that moves out of a hash map, \xe2\x80\xa6ClDraining parallel iterator that moves out of a hash set, \xe2\x80\xa6CkDraining parallel iterator that moves out of a binary heap,3CdDraining parallel iterator that moves a range of \xe2\x80\xa6BiA draining iterator for <code>Slab</code>DgAn iterator that removes the items from a <code>SmallVec</code> and \xe2\x80\xa6CaThe default Unicode collation element table orderBbThis value is obsolete and unused.0BkAlgorithmIdentifier for <code>ED448</code>.AlA value with all bits unset.nAn empty storemAn empty set.BiReturns the empty <code>Ready</code> set.AiInterest in error events.CjReturns a <code>Ready</code> representing error readiness.AfThe \xe2\x80\x9cerror\xe2\x80\x9d level.000DkA part that should annotate error segments in <code>TryWriteable</code> \xe2\x80\xa6Ak<code>Event</code> callsiteCiEager block buffer kind, which guarantees that buffer \xe2\x80\xa6CcPublic and optional private key on the given curve.BiRecommended ordering for emoji charactersCjUse an emoji presentation for emoji characters if possibleAjCharacters that are emoji.BlThe queue was empty at the time of stealing.BdThe channel is empty but not closed.BmReader for the <code>empty()</code> function.BkStream for the <code>empty</code> function.AlA body that is always empty.AbError: empty sliceCgIterator adaptor for the <code>empty()</code> function.BgAn empty regex that matches everything.nAn empty item.CkThe empty regular expression, which matches everything, \xe2\x80\xa6EmThis <strong>channel</strong> is currently empty, but the <strong>Sender</strong>(s) have \xe2\x80\xa6CjThe channel is currently empty. There are still active \xe2\x80\xa6CfThe send half of the channel has not yet sent a value.Ee<code>Empty</code> ignores any data written via <code>AsyncWrite</code>, and will \xe2\x80\xa6oAn empty field.0CmMatch the end of a line or the end of text. Specifically, \xe2\x80\xa60AoRepresents an executor context.ClA view into a single entry in a map, which may either be \xe2\x80\xa6ClA view into a single entry in a set, which may either be \xe2\x80\xa6CnA view into a single entry in a table, which may either be \xe2\x80\xa6DkA view into a single location in a <code>HeaderMap</code>, which may be \xe2\x80\xa6DiEntry for an existing key-value pair in an <code>IndexMap</code> or a \xe2\x80\xa6DgAn entry in a <code>LiteMap</code>, which may be either occupied or \xe2\x80\xa65CnA type whose byte sequence equals the byte sequence of its \xe2\x80\xa6DhA property set to a specific value, e.g., <code>\\p{scx=Katakana}</code>.DiA potential output from <code>Cmp</code>, this is the type equivalent \xe2\x80\xa6fUnusedBeWraps a platform-specific error code.DcThe <code>Error</code> type, a wrapper around a dynamic error type.AcBlock buffer error.BnAn error encountered during attribute parsing.BkThe type of failures yielded by this future0ChThe type of value produced by the sink when an error \xe2\x80\xa6101BcRepresents HTTP/2 operation errors.BjA generic \xe2\x80\x9cerror\xe2\x80\x9d for HTTP connectionsCeThe error type this <code>Body</code> might generate.AdAn error in parsing.BlAn opaque error type for all parsing errors.2CoThe error type that can occur within this <code>Service</code>.AoErrors produced by the service.CgRepresents errors that can occur handling HTTP streams.mClient errorsAfThe \xe2\x80\x9cerror\xe2\x80\x9d level.C`Corresponds to the <code>Error</code> log level.BnAn error returned from the TLS implementation.AoAn error reported from OpenSSL.mAn SSL error.BnThe type returned in the event of a RNG error.EbError type returned from <code>Uniform::new</code> and <code>new_inclusive</code>.AeInvalid weight errors2CnThis error type encompasses any error that can be returned \xe2\x80\xa6CmAn error that occurred while parsing a regular expression \xe2\x80\xa6EdAn error that can occur while translating an <code>Ast</code> to a <code>Hir</code>.ClErrors that may arise when parsing the contents of a PEM \xe2\x80\xa6ClThe error type that can be returned if some error occurs \xe2\x80\xa6CkThe error type when some error occurs during serialization.111110DfMust match the <code>Error</code> type of our <code>Serializer</code>.000000EcThe <code>Error</code> trait allows <code>Deserialize</code> implementations to \xe2\x80\xa6ClA minimal representation of all possible errors that can \xe2\x80\xa6DgTrait used by <code>Serialize</code> implementations to generically \xe2\x80\xa6545555543333333210CkThis type represents all possible errors that can occur \xe2\x80\xa602BiErrors returned during serializing to \xe2\x80\xa6CkError returned when a Syn parser cannot parse the input \xe2\x80\xa60BoErrors encountered by the timer implementation.C`The type of unrecoverable frame decoding errors.AlThe type of encoding errors.AoErrors produced by the service.AnErrors produced by the serviceBiErrors produced by the connecting service12CnAn error that occurs during certificate validation or name \xe2\x80\xa6AbA readiness event.Dg<code>Event</code>s represent single points in time where something \xe2\x80\xa6000CkA constant RawValue with the JSON value <code>false</code>.AiThe set of defined flags.Bc302 Found [RFC9110, Section 15.4.3]AhNo special case orderingBhNo special handling for numeric orderingDhAccess of a named struct field (<code>obj.k</code>) or unnamed tuple \xe2\x80\xa6BdA field of a struct or enum variant.EcAn opaque key allowing <em>O</em>(1) access to a field in a <code>Span</code>\xe2\x80\x99\xe2\x80\xa600Ab<code>final</code>BgFirst part of the resulting split arrayCkOnly use static/fixed blocks. (Blocks using the default \xe2\x80\xa6CdA set of defined flags using a bits type as storage.BiA set of flags, e.g., <code>(?is)</code>.AaA group of flags.BhGeneric trait for floating point numbersClA floating point number, f32 or f64, that can be written \xe2\x80\xa6EfThe input contained a floating point <code>f32</code> or <code>f64</code> that was \xe2\x80\xa60DfA floating point literal: <code>1f64</code> or <code>1.0e10f64</code>.2BiFuture for the <code>flush</code> method.0DeAn argument in a function signature: the <code>n: usize</code> in \xe2\x80\xa6CeA frame of any kind related to an HTTP stream (body).D`Future that resolves to the next frame from a <code>Body</code>.1AlRepresents a raw video frameBiAn entity that gives a value when wanted.AeInvisible characters.Ab<code>[!-~]</code>C`A token stream surrounded by bracket delimiters.AiA delimited token stream.AmA grouped regular expression.0CdAn expression contained within invisible delimiters.DmA braced group of imports in a <code>use</code> item: <code>{A, B, C}</code>.BmA type contained within invisible delimiters.AdNone-delimited groupBmA guard that keeps the current thread pinned.AgHTTP protocol over TLS.nHijri calendareimagenAn identifier.ChA word of Rust code, which may be a keyword or legal \xe2\x80\xa6CjA type parameter or const generic parameter in precise \xe2\x80\xa6BhA pattern that binds a new variable: \xe2\x80\xa62C`A slot in a type\xe2\x80\x99s \xe2\x80\x9cextra data\xe2\x80\x9d structure.DgA type that can be used to index into a <code>serde_json::Value</code>.AcAn interface index.CoA square bracketed indexing expression: <code>vector[2]</code>.BkThe index of an unnamed tuple struct field.DgThe inferred value of a const generic argument, denoted <code>_</code>.CnIndication that a type should be inferred by the compiler: \xe2\x80\xa6kInner type.CdThe configuration and the haystack to use for an \xe2\x80\xa6ClThe parameters for a regex search including the haystack \xe2\x80\xa6EcA wrapper around <code>&amp;&#39;a [u8]</code> that helps in writing panic-free \xe2\x80\xa6EaProvides a <code>saturating_add()</code> method for <code>Ipv4Addr</code> and \xe2\x80\xa6BkAn IP network address, either IPv4 or IPv6.EaProvides a <code>saturating_sub()</code> method for <code>Ipv4Addr</code> and \xe2\x80\xa6CiA word-sized signed integer stored in a given byte order.BkFuture for the <code>join3</code> function.BkFuture for the <code>join4</code> function.BkFuture for the <code>join5</code> function.H`E.g. <code>+</code> is <code>Joint</code> in <code>+=</code> or <code>&#39;</code> is <code>Joint</code> in <code>&#39;#</code>.CcThe total number of values that can be represented.0CkThe total number of values that can be represented as a \xe2\x80\xa611AmReturn <code>ln(10.0)</code>.EaA lifetime labeling a <code>for</code>, <code>while</code>, or <code>loop</code>.DhDecorates a <code>Service</code>, transforming either the request or \xe2\x80\xa600CdLevel of compression data should be compressed with.CnAn enum representing the available verbosity levels of the \xe2\x80\xa6CdDescribes the level of verbosity of a span or event.00DkA <code>BufMut</code> adapter which limits the amount of bytes that can \xe2\x80\xa6BiStream for the <code>lines</code> method.BhParallel iterator over lines in a stringBnReads lines from an <code>AsyncBufRead</code>.AfA local (let) binding.DhA local <code>let</code> binding: <code>let x: u64 = s.parse()?;</code>.AjCSS lev 3 line-break=looseBiLower case to be sorted before upper caseAb<code>[a-z]</code>emodelBmProtocol corresponding to <code>MPTCP</code>.DgA macro invocation expression: <code>format!(&quot;{}&quot;, q)</code>.D`A macro invocation, which includes <code>macro_rules!</code> \xe2\x80\xa6BjA macro invocation within an extern block.CdA macro invocation within the definition of a trait.BhA macro invocation within an impl block.AlA macro in pattern position.BiA macro invocation in statement position.AmA macro in the type position.CoA macro invocation: <code>println!(&quot;{}&quot;, mac)</code>.Ab<code>macro</code>BjFuture for the <code>map_ok</code> method.BjStream for the <code>map_ok</code> method.CgA confirmed match was found. Callers do not need to \xe2\x80\xa6CkA representation of a match reported by an Aho-Corasick \xe2\x80\xa6CkA match state. There is at least one such occurrence of \xe2\x80\xa6CgA representation of a match reported by a regex engine.EjA <code>match</code> expression: <code>match n { Some(n) =&gt; {}, None =&gt; {} }</code>.Ab<code>match</code>BbA reference to an <code>Md</code>.n<code>-</code>AfA futures-aware mutex.CmA mutual exclusion primitive useful for protecting shared \xe2\x80\xa60BmAn asynchronous <code>Mutex</code>-like type.CeDo not select a protocol, but continue the handshake.CkA set of named fields, e.g. <code>{ field: String }</code>.CmA binary property, general category or script. The string \xe2\x80\xa6CfNamed fields of a struct or struct variant such as \xe2\x80\xa6BgA named field like <code>self.x</code>.AoA type with no possible values.AoThe never type: <code>!</code>.CgA nonce for a single AEAD opening or sealing operation.CmAlias for the associated type of <code>IsNotEqual</code>: \xe2\x80\xa6DcThe literal is written as an octal escape, e.g., <code>\\141</code>.CjAn interface over the operating-system\xe2\x80\x99s random data \xe2\x80\xa60AjAll other extension types.CmA list of <code>Other Use Extensions</code> as defined in \xe2\x80\xa6Da(<code>C</code>) The union of all control code, reserved, and \xe2\x80\xa6ChA message stating what uncategorized thing the input \xe2\x80\xa60AoAn owned heap-allocated object.BaAn owned representation of a CRL.ePATCHeplainE`An iterator over borrowed pairs of type <code>Pair&lt;&amp;T, &amp;P&gt;</code>.oBad parameters.CaA parenthesized expression: <code>(a + b)</code>.BnA parenthesized pattern: <code>(A | B)</code>.CbA parenthesized type equivalent to the inner type.Ao<code>(</code>\xe2\x80\xa6<code>)</code>BhThe return type of <code>parse()</code>.ClAn error that occurred while translating concrete syntax \xe2\x80\xa6CjParsing interface implemented by all types that can be \xe2\x80\xa6C`Component parts of an HTTP <code>Response</code>BoComponent parts of an HTTP <code>Request</code>AkThe various parts of a URI.CaDeconstructed parts of a <code>Connection</code>.0CiThe deconstructed parts of an <code>Upgraded</code> type.0CaA pattern that matches any one of a set of cases.BhA type that can be used as a pixel type.AbAn RSA private keyAcA PKCS#7 structure.AdA PKCS#8 private keyAjOne data plane of a frame.AjPOSIX style locale variantn<code>#</code>CiPrintable characters (visible characters and whitespace).Ab<code>[ -~]</code>EfA single punctuation character (<code>+</code>, <code>,</code>, <code>$</code>, etc.).FmA <code>Punct</code> is a single punctuation character like <code>+</code>, <code>-</code> or <code>#</code>.Al<code>[!-/:-@\\[-`{-~]</code>DeThe explicit Self type in a qualified path: the <code>T</code> in \xe2\x80\xa6BdAn escaped quote <code>&quot;</code>CkIndicates the part of a document that the server should \xe2\x80\xa6BeReturn from the handshake with an \xe2\x80\xa6AmA range between two literals.Ab<code>{m,n}</code>GaA range expression: <code>1..2</code>, <code>1..</code>, <code>..2</code>, <code>1..=2</code>, <code>..=2</code>.BdA range pattern: <code>1..=2</code>.BiRepresents the ratio between two numbers.BkFuture for the <code>ready</code> function.CbDescribes the readiness state of an I/O resources.CkA future that yields a mutable reference to the service \xe2\x80\xa6CiA regex matcher that works by composing several other \xe2\x80\xa6ChA regular expression that uses hybrid NFA/DFAs (also \xe2\x80\xa6CgA regular expression that uses deterministic finite \xe2\x80\xa6AaResettable types.00BhThe steal operation needs to be retried.CfConfigure retrying requests of \xe2\x80\x9cfailed\xe2\x80\x9d responses.CeTruncate right side, i.e. <code>&amp;out[m..]</code>.AoA value of type <code>R</code>.AiSecond branch of the typeAgPoll the second stream.AnA value of type <code>R</code>3CkProvides methods to compute an integer\xe2\x80\x99s square root, \xe2\x80\xa6AmA scope for spawning threads.CkRepresents a fork-join scope which can be used to spawn \xe2\x80\xa60ChDescription of how fields in a struct or variant are \xe2\x80\xa6Af<code>&lt;&lt;=</code>Af<code>&gt;&gt;=</code>AkAn ID of registered action.n<code>/</code>BjA future returned by a <code>Timer</code>.DcFuture returned by <code>sleep</code> and <code>sleep_until</code>.DkA dynamically-sized slice of key-value pairs in an <code>IndexMap</code>\xe2\x80\xa6D`A dynamically-sized slice of values in an <code>IndexSet</code>.DkA dynamically sized slice pattern: <code>[a, b, ref i @ .., y, z]</code>\xe2\x80\xa6CaA dynamically sized slice type: <code>[T]</code>.AgThe trie type is small.ClRepresents the \xe2\x80\x9csmall\xe2\x80\x9d type code point tries for the \xe2\x80\xa6EfSpace, spelled <code>\\ </code> (<code>\\x20</code>). Note that this can only appear \xe2\x80\xa6kWhitespace.Aj<code>[\\t\\n\\v\\f\\r ]</code>DcThe <code>Spawn</code> trait allows for pushing futures onto an \xe2\x80\xa60DkDefines a <code>GenericSequence</code> that can be split into two parts \xe2\x80\xa6Dh<code>Split</code> is a parallel iterator using arbitrary data and a \xe2\x80\xa6CfParallel iterator over slices separated by a predicateChParallel iterator over substrings separated by a patternCkYields all substrings delimited by a regular expression \xe2\x80\xa6BkSplitter for the <code>split</code> method.DfA <code>T</code> that has been split into two possibly-overlapping \xe2\x80\xa6CaThe SSL 3.0 protocol is insecure. Don\xe2\x80\x99t use it.BaAn owned stack of <code>T</code>.BaTwo middlewares chained together.0CnMatch the beginning of text. Specifically, this matches at \xe2\x80\xa60AbA state in an NFA.CcA handle to the standard input stream of a process.BgPossible outcomes of a steal operation.BoTrait to enable pluggable backends for LiteMap.Ab<code>super</code>eTRACEAfThe \xe2\x80\x9ctrace\xe2\x80\x9d level.000AmAn entity that wants a value.CcFinds all occurrences of three bytes in a haystack.00AmThree successive byte ranges.n<code>~</code>BlA timer which provides timer-like functions.DoA <strong>type operator</strong> for taking a concrete integer value from a \xe2\x80\xa6BeInvalid byte where token is required.CmAssociates readiness events with <code>event::Source</code>s.CjA type-macro that expands to the name of the Rust type \xe2\x80\xa6CdMarker trait for types that represent single tokens.:C`Corresponds to the <code>Trace</code> log level.ClA trait definition: <code>pub trait Iterator { ... }</code>.Ab<code>trait</code>CjA list of unnamed fields, e.g. <code>(String, u64)</code>.BnA tuple expression: <code>(a, b, c, d)</code>.BeA tuple pattern: <code>(a, b)</code>.BmA tuple type: <code>(A, B, C, String)</code>.CkHolder for either fast or small trie with the trie type \xe2\x80\xa6CaA function argument accepted by pattern and type.AiCredentials of a process.eutf-8DiThe terminating type for <code>UInt</code>; it always comes after the \xe2\x80\xa6CdA unary operation: <code>!x</code>, <code>*x</code>.DjA lazy iterator producing elements in the union of <code>HashSet</code>\xe2\x80\xa6DkA lazy iterator producing elements in the union of <code>IndexSet</code>\xe2\x80\xa6CdAn alternation such that there exists an epsilon \xe2\x80\xa6AaA union of items.DfA union definition: <code>union Foo&lt;A, B&gt; { x: A, y: B }</code>.Ab<code>union</code>BiFuture for the <code>unzip</code> method.BiUpper case to be sorted before lower caseAb<code>[A-Z]</code>CkA word-sized unsigned integer stored in a given byte order.evcardevideoCjDomain for low-level VSOCK interface, corresponding to \xe2\x80\xa6C`A value used in a list of <code>Keywords</code>.BnA value used in a list of <code>Fields</code>.BeThe type produced by using this seed.BcThe value produced by this visitor.10B`Represents any valid JSON value.0B`A field value of an erased type.00CmSyntax tree traversal to walk a shared borrow of a syntax \xe2\x80\xa6AdVisits typed values.0ewoff2CfWaker allows cross-thread waking of <code>Poll</code>.Ab<code>where</code>BnA while loop: <code>while expr { ... }</code>.Ab<code>while</code>BiFuture for the <code>write</code> method.AkWrite bytes asynchronously.DaResult of <code>yield_now()</code> or <code>yield_local()</code>.0BlA yield expression: <code>yield expr</code>.Ab<code>yield</code>DkAn <code>IndexedParallelIterator</code> that iterates over two parallel \xe2\x80\xa6BmBuild an ioctl number for a read-write ioctl.DgAbort the <code>Abortable</code> stream/future associated with this \xe2\x80\xa6BjAbort the task associated with the handle.0oArccosine (f32)AoInverse hyperbolic cosine (f64)BcInverse hyperbolic cosine function.0BkRepresents the <code>SIGALRM</code> signal.CkReturns this certificate\xe2\x80\x99s \xe2\x80\x9calias\xe2\x80\x9d. This field is \xe2\x80\xa6ChParallel iterator types for arrays (<code>[T; N]</code>)BiA type-level array of type-level numbers.EeReturns the <code>Id</code> of the span that <code>self</code> corresponds to, or \xe2\x80\xa6ClIf this unit is not an \xe2\x80\x9cend of input\xe2\x80\x9d sentinel, then \xe2\x80\xa6mArcsine (f32)AmInverse hyperbolic sine (f64)BaInverse hyperbolic sine function.0AgArctangent of y/x (f64)FeComputes the four quadrant arctangent of <code>self</code> (<code>y</code>) and <code>other</code>\xe2\x80\xa60A`Arctangent (f32)B`Inverse hyperbolic tangent (f64)BdInverse hyperbolic tangent function.0CiThis module contains scaffolding for baked providers, \xe2\x80\xa6AkReturns the basic response.CnCreates a cursor referencing the first token in the buffer \xe2\x80\xa6FfReturns the union of <code>self</code> and <code>rhs</code> as a new <code>HashSet&lt;T, S&gt;</code>.BmReturns the set union, cloned into a new set.D`The bitwise or (<code>|</code>) of the bits in two flags values.00000000000DdReturns a new hint that is correct wherever <code>self</code> is \xe2\x80\xa6CnThe <code>BlockRngCore</code> trait and implementation helpersBeWrap the future in a Box, pinning it.0BeWrap the stream in a Box, pinning it.0BiTurn this body into a boxed trait object.EaConvert the service into a <code>Service</code> + <code>Send</code> trait object.0DhThis wraps the inner service with the <code>Layer</code> returned by \xe2\x80\xa6CkBuild an Aho-Corasick automaton using the configuration \xe2\x80\xa6ClBuild a searcher from the patterns added to this builder \xe2\x80\xa6ChBuild an Aho-Corasick DFA from the given iterator of \xe2\x80\xa6CgBuild an Aho-Corasick contiguous NFA from the given \xe2\x80\xa6CjBuild an Aho-Corasick noncontiguous NFA from the given \xe2\x80\xa6DjConsumes this builder, and tries to construct a valid <code>Uri</code> \xe2\x80\xa6CnCombine the configuration of this builder with a connector \xe2\x80\xa6CmConstruct a <code>Matcher</code> using the configured values.CcInvoke the builder and return a <code>Record</code>BgReturns a <code>Metadata</code> object.BhCreates a new <code>TlsConnector</code>.BgCreates a new <code>TlsAcceptor</code>.kDeprecated.AdReturns the Rsa key.CmConsumes the builder, returning an <code>SslConnector</code>.CkConsumes the builder, returning a <code>SslAcceptor</code>.CnConsumes the builder, returning a new <code>SslContext</code>.C`Consumes the builder, returning the certificate.B`Return an <code>X509Name</code>.BaReturns the <code>X509Req</code>.BfConstructs the <code>X509Store</code>.EdReturn the <code>BasicConstraints</code> extension as an <code>X509Extension</code>.DlReturn the <code>KeyUsage</code> extension as an <code>X509Extension</code>.EdReturn the <code>ExtendedKeyUsage</code> extension as an <code>X509Extension</code>.EhReturn a <code>SubjectKeyIdentifier</code> extension as an <code>X509Extension</code>\xe2\x80\xa6D`Return a <code>AuthorityKeyIdentifier</code> extension as an \xe2\x80\xa6D`Return a <code>SubjectAlternativeName</code> extension as an \xe2\x80\xa6D`Creates a new <code>ThreadPool</code> initialized using this \xe2\x80\xa60CmDeprecated in favor of <code>ThreadPoolBuilder::build</code>.CiBuilds a <code>Regex</code> from a single pattern string.BcBuild a DFA from the given pattern.BlBuild a one-pass DFA from the given pattern.BeBuild a regex from the given pattern.BhBuild a lazy DFA from the given pattern.1CiAssemble a <code>NFA</code> from the states added so far.CiCompile the given regular expression pattern into an NFA.CcBuild a <code>PikeVM</code> from the given pattern.CoBuild a <code>BoundedBacktracker</code> from the given pattern.CiBuild a parser from this configuration with the given \xe2\x80\xa60CcBuild a translator using the current configuration.BlCreates the configured <code>Runtime</code>.CnConstruct a RevocationOptions instance based on the builder\xe2\x80\xa6BmProvides abstractions for working with bytes.CjA possibly non-sized field containing a sequence of bytes.CnAccepts a replacement byte string and interpolates capture \xe2\x80\xa6iTODO: docAjGets the underlying bytes.DkThe lower-level cause of this error, in the case of a <code>Utf8</code> \xe2\x80\xa6oCube root (f32)jCeil (f32)CjAn iterator of the chain of source errors contained by \xe2\x80\xa6ChCreates an adaptor which will chain this buffer with \xe2\x80\xa60BfDigest input data in a chained manner.ChCreates an adaptor which will chain this stream with \xe2\x80\xa6BaAdapter for chaining two streams.03DiReturns a reference to a complete valid <code>X509</code> certificate \xe2\x80\xa6CiTakes two iterators and creates a new iterator over both.DiCreates a new <code>AsyncRead</code> instance that chains this stream \xe2\x80\xa60CjCheck if a field container\xe2\x80\x99s shape is in this set of \xe2\x80\xa6CnReturns an error if and only if Unicode word boundary data \xe2\x80\xa6BkRepresents the <code>SIGCHLD</code> signal.CkReturns a slice starting at the current position and of \xe2\x80\xa60BjA value bounded by a minimum and a maximum0BeClamps a value between a min and max.CkCreates a class HIR expression. The class may either be \xe2\x80\xa6CiDrops the all the elements of the vector, setting its \xe2\x80\xa6BbRemove all elements in the vector.AfMake the string empty.AmUnsets all bits in the flags.0BeClears the buffer, removing all data.CnClears the buffer, removing all data. Existing capacity is \xe2\x80\xa6BdRemove any existing name/value pair.CbClear the whole <code>FuturesOrdered</code> queue.BeClears the set, removing all streams.BeClears the set, removing all futures.CkClears the map, removing all key-value pairs. Keeps the \xe2\x80\xa6BdClears the set, removing all values.BfClears the table, removing all values.CmClear the <code>Extensions</code> of all inserted extensions.39BiEmpties the <code>Attributes</code> list.CjClears all Unicode extension keywords, leaving Unicode \xe2\x80\xa6CiClears all Unicode extension keywords and attributes, \xe2\x80\xa6BeEmpties the <code>Fields</code> list.CkClears the transform extension, effectively removing it \xe2\x80\xa6BfEmpties the <code>Private</code> list.BgEmpties the <code>Variants</code> list.CkRemove all key-value pairs in the map, while preserving \xe2\x80\xa6ChRemove all elements in the set, while preserving its \xe2\x80\xa6CaRemove all elements from the <code>LiteMap</code>DaClearing all <code>Event</code> values from container explicitly.DkErases the memory used by this <code>BigNum</code>, resetting its value \xe2\x80\xa6CdClear this set such that it contains no pattern IDs.AcClear this builder.BgClear this <code>Captures</code> value.BdClears the map, removing all values.AmClear the slab of all values.BdRemove all elements from the vector.CmClears the sequence of all values and punctuation, making \xe2\x80\xa6ChClears the buffer, resetting the filled region to empty.ClRemove all elements from this ZeroVec and reset it to an \xe2\x80\xa6BcReturns a copy of the atomic value.ChCreates another reference to the same garbage collector.DjReturns a cloned <code>AbortHandle</code> that can be used to remotely \xe2\x80\xa6DhCreates a clone of the <code>CancellationToken</code> which will get \xe2\x80\xa6BdClones this <code>PollSender</code>.ClCloses the receiving half of a channel, without dropping \xe2\x80\xa60CmGracefully close this receiver, preventing any subsequent \xe2\x80\xa6DhCreates a future which will entirely close this <code>AsyncWrite</code>.oClose the sink.CkReturns a span for the closing punctuation of the group \xe2\x80\xa6AeCloses the semaphore.CkCloses the receiving half of a channel without dropping it.6DhPrevents the associated <code>Sender</code> handle from sending a value.2AcCloses this sender.DkAdaptors from <code>AsyncRead</code>/<code>AsyncWrite</code> to Stream/SinkCjReturns a reference to the underlying codec wrapped by \xe2\x80\xa6iThe codecAgHyperbolic cosine (f64)CkDrives the stream to completion, counting the number of \xe2\x80\xa60CjCounts all occurrences of this byte in the given haystack.00CeCounts the number of items in this parallel iterator.BaDetermine if two items are equal.EnTwo <code>CtOption&lt;T&gt;</code>s are equal if they are both <code>Some</code> and their \xe2\x80\xa6BoDetermine whether <code>self &gt; other</code>.BoDetermine whether <code>self &lt; other</code>.BeDetermine if two items are NOT equal.AkRepeats a stream endlessly.0BbLogs a message at the debug level.BgConstructs an event at the debug level.EeWraps a type implementing <code>fmt::Debug</code> as a <code>Value</code> that can be0CjDeduplicate adjacent equivalent literals in this sequence.BgRemoves consecutive duplicate elements.CnStores a function so that it can be executed at some point \xe2\x80\xa6CgMacro to create a <code>ScopeGuard</code> (always run).BoGets an immutable reference to the denominator.BjTypes and routines specific to dense DFAs.ChSet the dense DFA compilation configuration for this \xe2\x80\xa6AoDereferences the given pointer.AiDereferences the pointer.ChGenerating random samples from probability distributionsCiCreate a draining iterator that removes the specified \xe2\x80\xa6CkCreate a sink that will just discard all items given to it.CgClears the map, returning all key-value pairs as an \xe2\x80\xa6CfClears the set, returning all elements in an iterator.0CeClears the map, returning all entries as an iterator.DhClears the <code>IndexMap</code> in the given index range, returning \xe2\x80\xa6DhClears the <code>IndexSet</code> in the given index range, returning \xe2\x80\xa6CmReturn a draining iterator that removes all elements from \xe2\x80\xa6CjCreates a draining iterator that removes the specified \xe2\x80\xa6CgInternal method used to define the behavior of this \xe2\x80\xa6ChLow level Elliptic Curve Digital Signature Algorithm \xe2\x80\xa6DeReturns the contents of this <code>GeneralName</code> if it is an \xe2\x80\xa6BaSets the <code>email</code> flag.BfGet a flags value with all bits unset.0BkConstructs a new handle to an empty reader.BlCreates a stream which contains no elements.AfReturn the empty groupCcCreates an empty <code>DataMarkerAttributes</code>.444444444444CbCreates a parallel iterator that produces nothing.BnCreate an empty set of look-around assertions.ClCreates a new set of equivalence classes where all bytes \xe2\x80\xa6CfCreate new storage for only tracking which pattern \xe2\x80\xa6BmThis creates an empty <code>GroupInfo</code>.AoCreate an \xe2\x80\x9cempty\xe2\x80\x9d AST item.B`Returns an empty HIR expression.BbCreate a new class with no ranges.06AjReturns an empty sequence.BdConstruct an empty <code>Aad</code>.ChCreates a cursor referencing a static empty TokenStream.ChCreates a value that is always at EOF for reads, and \xe2\x80\xa6ChMarks the current thread as being within the dynamic \xe2\x80\xa6ClEnters the runtime context. This allows you to construct \xe2\x80\xa6AkEnters the runtime context.CaEnters the context of this <code>LocalSet</code>.BeRecords that a span has been entered.BgRecords that a span has been can_enter.1CjEnters this span, returning a guard that will exit the \xe2\x80\xa6212CmGets the given key\xe2\x80\x99s corresponding entry in the map for \xe2\x80\xa6CkGets the given value\xe2\x80\x99s corresponding entry in the set \xe2\x80\xa6DjReturns an <code>Entry</code> for an entry in the table with the given \xe2\x80\xa6BoThe entry in the map that was already occupied.3ClGet the given key\xe2\x80\x99s corresponding entry in the map for \xe2\x80\xa6ClGets the entry for the given key in the map for in-place \xe2\x80\xa65BbComplementary error function (f32)ClCross-platform interface to the <code>errno</code> variable.CjReturns the platform-specific value of <code>errno</code>.EfThe <code>darling::Error</code> type, the multiple error <code>Accumulator</code>, \xe2\x80\xa6BgReturns a reference to the inner error.BbLogs a message at the error level.BcErrors returned by OpenSSL library.CgReturns the underlying error which interrupted this \xe2\x80\xa6BfReturns the error code of the context.A`Error reporting.CbWhen serializing or deserializing JSON goes wrong.ClReport that the attribute\xe2\x80\x99s content did not conform to \xe2\x80\xa6CjTriggers an error at the current position of the parse \xe2\x80\xa600AdChannel error types.AeBroadcast error typesAbWatch error types.Ba<code>Oneshot</code> error types.AaTime error types.kError types0BgConstructs an event at the error level.BaTypes related to error reporting.BdReadiness event types and utilities.CeEvents represent single points in time during the \xe2\x80\xa6C`Records that an <code>Event</code> has occurred.0BdConstructs a new <code>Event</code>.11112DoReturns the exact size of data that will be yielded <strong>if</strong> the \xe2\x80\xa60CgReturns a new exact literal containing the bytes given.Bo<code>write_to</code> will use exactly n bytes.CjCalculates 10 raised to the power of <code>x</code> (f64).AiExponential, base 2 (f32)BjExponential, base <em>e</em>, of x-1 (f64)DkReturns the <code>extra</code> field of this gzip stream\xe2\x80\x99s header, if \xe2\x80\xa6CjConfigure the <code>extra</code> field in the gzip header.CeSet extra connection information to be set in the \xe2\x80\xa6CnItems which do not have a correspondence to any API in the \xe2\x80\xa6B`Absolute value (magnitude) (f32)AiPositive difference (f32)CjFetches a cipher object corresponding to the specified \xe2\x80\xa6DdFetches an <code>Md</code> object corresponding to the specified \xe2\x80\xa6Ch<code>Span</code> and <code>Event</code> key-value data.FaReturns the <code>Field</code> named <code>name</code>, or <code>None</code> if no such field \xe2\x80\xa6EgReturns a <code>Field</code> for the field with the given <code>name</code>, if one \xe2\x80\xa612AmGet the first key-value pair.AlGet the first key-value pairAdGet the first value.AcGet the first valueDkGet the lowest-rank key/value pair from the <code>LiteMap</code>, if it \xe2\x80\xa6BkBorrows the first element in this sequence.CkGets the first element. Returns <code>None</code> if empty.AmGet the raw compressor flags.AhGets verification flags.AnCreate a \xe2\x80\x9cflags\xe2\x80\x9d AST item.CiIf this group is non-capturing, then this returns the \xe2\x80\xa6AmThe actual sequence of flags.BaReturns the flags of the message.kFloor (f64)AnRounds towards minus infinity.CkReturns the largest integer less than or equal to a number.00CjBecause this is usually treated as OK to call multiple \xe2\x80\xa6CmClears up the thread-local cache of deferred functions by \xe2\x80\xa6DhCreates a future which will entirely flush this <code>AsyncWrite</code>.BmFlush the sink, processing all pending items.AmFlushes any buffered records.CaFlushes this output stream, ensuring that all \xe2\x80\xa60BdFlushes any internal buffer, if any.AjFlush any internal buffer.0CnReturn the greater of two arguments or, if either argument \xe2\x80\xa6CmReturn the lesser of two arguments or, if either argument \xe2\x80\xa6DhCalculate the remainder of <code>x / y</code>, the precise result of \xe2\x80\xa6CjForces the evaluation of this lazy value and returns a \xe2\x80\xa60CjReturns the fractional part of a number, with division \xe2\x80\xa6BhReturns the fractional part of a number.00DfReturns a future that resolves to the next <code>Frame</code>, if any.ClLookup trie value by Basic Multilingual Plane Code Point \xe2\x80\xa60DfReturns the value that is associated with <code>bmp</code> in this \xe2\x80\xa61CmLookup trie value by Unicode Code Point without branching \xe2\x80\xa60DhReturns the value that is associated with <code>code_point</code> in \xe2\x80\xa6AkSee <code>Self::get</code>.AmA type representing group ID.C`A slice starting i pixels above the current one.AjReturns the key\xe2\x80\x99s group.AnCreate a \xe2\x80\x9cgroup\xe2\x80\x9d AST item.DdIf the cursor is pointing at a <code>Group</code> with the given \xe2\x80\xa6EhCreate a new <code>ScopeGuard</code> owning <code>v</code> and with deferred closure \xe2\x80\xa6AfGetting started guide.DhReturn an <code>Iterator</code> over the host addresses in this network.00AiHTTP/1 client connectionsAiHTTP/1 Server ConnectionsAdHttp1 configuration.0AiHTTP/2 client connectionsAiHTTP/2 Server ConnectionsAdHttp2 configuration.0BlSet the target proxy for HTTPS destinations.ehyperCkCalculate the length of the hypotenuse of a right-angle \xe2\x80\xa60AdName of the variant.AjName of the field, if any.DfThe <code>example</code> in <code>macro_rules! example { ... }</code>.DgIf the cursor is pointing at a <code>Ident</code>, returns it along \xe2\x80\xa6DaHelper functions for implementing <code>RngCore</code> functions.CiReturns a reference to the value corresponding to the \xe2\x80\xa6fPanicsBfReturn the index of the key-value pairChReturn the index where a key-value pair may be inserted.ClReturn the index where the key-value pair exists or will \xe2\x80\xa62DbReturns a reference to the key at the supplied <code>index</code>.DdReturns a reference to the value at the supplied <code>index</code>.6CnReturn the index where the key-value pair exists or may be \xe2\x80\xa6541BbLow-level API for sampling indicesCaReturn the value at the given <code>index</code>.BeGet the index into the result buffer.0ChOur index amongst the broadcast threads (ranges from \xe2\x80\xa6CeGets the index of this thread in the pool, within \xe2\x80\xa610AbThe capture index.BaThe capture index of the capture.EeIndex into a <code>serde_json::Value</code> using the syntax <code>value[0]</code> orCmReturns the index of this field in its <code>FieldSet</code>.0BfReturns a reference to the inner type.0AfBorrow the inner type.AiBorrows the wrapped type.0DeReturns the current <code>Input</code> associated with this iterator.000CmReturns the current <code>Input</code> used by this iterator.0CmReturns the current <code>Input</code> used by this searcher.11BjTypes for IPv4 and IPv6 network addresses.BiReturns true if the error is an io::ErrorCnReturns true if this error was caused by a failure to read \xe2\x80\xa6BnThe sequence of items that make up this union.CmA sequence of flag items. Each item is either a flag or a \xe2\x80\xa6CaSame as <code>join</code>, but with more futures.00BaSets the <code>keyid</code> flag.CgA collection of <code>Layer</code> based tower servicesCkWrap the given service with the middleware, returning a \xe2\x80\xa6FaReturns a <code>Layer</code> for wrapping a <code>Service</code> in a <code>BoxService</code> \xe2\x80\xa6DjReturns a <code>Layer</code> for wrapping a <code>Service</code> in an \xe2\x80\xa6FbReturns a <code>Layer</code> for wrapping a <code>Service</code> in a <code>BoxCloneService</code>DiReturns a <code>Layer</code> for wrapping a <code>Service</code> in a \xe2\x80\xa6DmReturns a new <code>Layer</code> that produces <code>AndThen</code> services.DlReturns a new <code>Layer</code> that produces <code>MapErr</code> services.E`Returns a new <code>Layer</code> that produces <code>MapRequest</code> services.EaReturns a new <code>Layer</code> that produces <code>MapResponse</code> services.DoReturns a new <code>Layer</code> that produces <code>MapResult</code> services.DoReturns a new <code>Layer</code> that produces <code>MapFuture</code> services.DjReturns a new <code>Layer</code> that produces <code>Then</code> services.DdAdd a new layer <code>T</code> into the <code>ServiceBuilder</code>.<<CjReturns an integer representing the compression level, \xe2\x80\xa6BcThe verbosity level of the message.BaSet <code>Metadata::level</code>.1AnSetter for <code>level</code>.CkReturns the level of verbosity of the described span or \xe2\x80\xa60Cnlog of how big the ring buffer should be for copying prior \xe2\x80\xa6DjCreates an adaptor which can write at most <code>limit</code> bytes to \xe2\x80\xa60CgReturns the maximum number of bytes that can be writtenCeReturns the maximum number of bytes that can be read.CjReturns the remaining number of bytes that can be read \xe2\x80\xa60ChReturns a stream over the lines of this reader. This \xe2\x80\xa600DhReturns <code>ln(1+n)</code> (natural logarithm) more accurately than if0BnThe base 10 logarithm of <code>x</code> (f64).BlReturns the base 10 logarithm of the number.0C`The natural logarithm of 1+<code>x</code> (f64).BmThe base 2 logarithm of <code>x</code> (f32).DiReturns the lower bound of data that the <code>Body</code> will yield \xe2\x80\xa60DhMerge two <code>SemaphorePermit</code> instances together, consuming \xe2\x80\xa6DcMerge two <code>OwnedSemaphorePermit</code> instances together, \xe2\x80\xa6CgThis gives the most recent modification time of the \xe2\x80\xa6CjConfigure the <code>mtime</code> field in the gzip header.CnReturns a reference to the original <code>Mutex</code> object.CgReturns a reference to the original <code>Mutex</code>.DbReturns a reference to the original <code>Arc&lt;Mutex&gt;</code>.Ch\xf0\x9f\x9a\xa7 [Unstable] Property names-related data for this \xe2\x80\xa6CaThis module contains the <code>Never</code> type.DfReturns an <code>Interest</code> indicating that the subscriber is \xe2\x80\xa60EbPlaces the result of <code>a mod m</code> in <code>self</code>.  As opposed to \xe2\x80\xa6BmGets an immutable reference to the numerator.BgWhether to support octal syntax or not.00DbPlaces the order of the curve in the provided <code>BigNum</code>.CkOther Use Extensions is a list of extensions other than \xe2\x80\xa6CnA sequence of any other extensions that are present in the \xe2\x80\xa6B`Sets a flag not already defined.CmReturns an iterator over the contents of this sequence as \xe2\x80\xa6B`Convert a byte string in the \xe2\x80\xa6C`Try to parse a buffer of bytes into the Request.CoTry to parse a buffer of bytes into this <code>Response</code>.kDeprecated.CkA convenience routine for parsing a pattern into an HIR \xe2\x80\xa6CkA convenience routine for parsing a regex using default \xe2\x80\xa6CkParse the regular expression into a high level intermediateCaThis module provides a regular expression parser.CjParse the regular expression into an abstract syntax tree.CnParsing interface for parsing a token stream into a syntax \xe2\x80\xa6CkParse tokens of source code into the chosen syntax tree \xe2\x80\xa6ClParse a syntax tree node from the content of this string \xe2\x80\xa6DcParses a syntax tree node of type <code>T</code>, advancing the \xe2\x80\xa62BjConstruct a parse error for the given typeAlgithub\xe2\x80\x82crates-io\xe2\x80\x82docs-rsDjCreates a new <code>Builder</code> initialized with a PATCH method and \xe2\x80\xa6BkAdd a transition from one state to another.CcLooks at the second-next token in the parse stream.CbLooks at the third-next token in the parse stream.CbA type representing process and process group IDs.B`PKCS#8 is specified in RFC 5958.DgThis module provides a regular expression printer for <code>Ast</code>.DiPrint the given <code>Ast</code> to the given writer. The writer must \xe2\x80\xa6DgThis module provides a regular expression printer for <code>Hir</code>.1CkProbe the current system for the \xe2\x80\x9ccert file\xe2\x80\x9d and \xe2\x80\x9c\xe2\x80\xa6ClSteps the cursor one character into the trie based on an \xe2\x80\xa6BcProbes the next byte in the cursor.BmThis module defines all available properties.oProxy utilitiesmProxy helpersChSet whether the connected transport is to an HTTP proxy.DgIf the cursor is pointing at a <code>Punct</code>, returns it along \xe2\x80\xa6CmBorrows the punctuation from this punctuated pair, unless \xe2\x80\xa6BbReturns the query string componentEaGet the query string of this <code>Uri</code>, starting after the <code>?</code>.Algithub\xe2\x80\x82crates-io\xe2\x80\x82docs-rsA`The whole point.CmLike <code>Input::span</code>, but accepts any range instead.AmReturns this span as a range.BbReturns the match span as a range.CcRange of code points from start to end (inclusive).CkParallel iterator types for ranges, the type for values \xe2\x80\xa6432CmRayon is a data-parallelism library that makes it easy to \xe2\x80\xa6CkExtracts the successful type of <code>Poll&lt;T&gt;</code>.0ChCreates a future that is immediately ready with a value.EfConsumes <code>self</code>, returning a future that returns <code>self</code> back \xe2\x80\xa6BcWaits until the dispatcher is ready0BlWaits for any of the requested ready states.000BkWait for any of the requested ready states.111111111ClWaits for any of the requested ready states, returning a \xe2\x80\xa6ClGet the <code>Ready</code> value associated with this guard.0CnYields a mutable reference to the service when it is ready \xe2\x80\xa60AgReturns the reciprocal.ClTake the reciprocal (inverse) of a number, <code>1/x</code>.CjReturns the reciprocal (multiplicative inverse) of the \xe2\x80\xa61D`Returns the <code>Regex</code> value that created this iterator.0B`A DFA-backed <code>Regex</code>.BeA lazy DFA backed <code>Regex</code>.BoUnpins and then immediately re-pins the thread.C`Reset buffer by setting cursor position to zero.AeReset the hash state.B`Resets the <code>Backoff</code>.BaReset state to its initial value.0BkReset hasher instance to its initial state.01nReset the CRC.BmReset the Crc in this <code>CrcReader</code>.BmReset the Crc in this <code>CrcWriter</code>.CdQuickly resets this compressor without having to \xe2\x80\xa6CkPerforms the equivalent of replacing this decompression \xe2\x80\xa6CkResets the state of this encoder entirely, swapping out \xe2\x80\xa6CkResets the state of this decoder entirely, swapping out \xe2\x80\xa61010101010CoReset a future to resolve at <code>new_deadline</code> instead.0CgReset the state of the compressor, keeping the same \xe2\x80\xa6nPerforms resetCnReset the decompressor without re-allocating memory, using \xe2\x80\xa6BiResets the underlying EVP_MD_CTX instanceCdResets a <code>SpinWait</code> to its initial state.ClReset the number of available results. This will force a \xe2\x80\xa60CkReset this cache such that it can be used for searching \xe2\x80\xa600000?AjResets the internal state.ChResets the interval to complete one period after the \xe2\x80\xa6CiResets the <code>Sleep</code> instance to a new deadline.B`Resets the state of the context.0BnMiddleware for retrying \xe2\x80\x9cfailed\xe2\x80\x9d requests.ChCheck the policy if a certain request should be retried.CjRetry failed requests according to the given retry policy.CiReturn the last occurrence of the needle in the given \xe2\x80\xa6ClReturn the last occurrence of one of the needle bytes in \xe2\x80\xa60EfReturn the last occurrence of the <code>needle</code> in the <code>haystack</code> \xe2\x80\xa6EhReturns the last occurrence of <code>needle</code> in the given <code>haystack</code>\xe2\x80\xa6222222CiReturns the index of the last occurrence of the given \xe2\x80\xa6CnReturns the index of the last occurrence of this needle in \xe2\x80\xa6EmConvert the right side of <code>Either&lt;L, R&gt;</code> to an <code>Option&lt;R&gt;</code>.0DgRound <code>x</code> to the nearest integer, breaking ties toward even.DhRound <code>x</code> to the nearest integer, breaking ties away from \xe2\x80\xa6CmRounds to the nearest integer. Rounds half-way cases away \xe2\x80\xa6CkReturns the nearest integer to a number. Round half-way \xe2\x80\xa600BiCreates a new scope for spawning threads.DjCreates a \xe2\x80\x9cfork-join\xe2\x80\x9d scope <code>s</code> and invokes the closure \xe2\x80\xa6CjCreates a scope that executes within this thread pool. \xe2\x80\xa610EbSets a value <code>T</code> as the task-local value for the future <code>F</code>.eSerdeBlThe hyperbolic sine of <code>x</code> (f32).ClReturn a future that resolves in <code>duration</code> time.BnWaits until <code>duration</code> has elapsed.BoReturns a slice of self for the provided range.0AiDistributions over slicesBbParallel iterator types for slicesCjReturns the underlying slots, where each slot stores a \xe2\x80\xa6CmReturns the starting and ending slot corresponding to the \xe2\x80\xa6AgSpawns a scoped thread.BoSpawns a scoped thread with this configuration.DhSpawns a task that polls the given future with output <code>()</code> to0CmPuts the task into the Rayon thread pool\xe2\x80\x99s job queue in \xe2\x80\xa6DjSpawns a job into the fork-join scope <code>self</code>. This job will \xe2\x80\xa6CnSpawns an asynchronous task in this thread pool. This task \xe2\x80\xa6210BgSpawns a future onto the Tokio runtime.0ChExecutes the command as a child process, returning a \xe2\x80\xa6DkSpawns a new asynchronous task, returning a <code>JoinHandle</code> for \xe2\x80\xa6DeSpawn the provided task on the <code>JoinSet</code>, returning an \xe2\x80\xa6CkCreate a new span using the given position as the start \xe2\x80\xa6CnRemoves the bytes from the current view, returning them in \xe2\x80\xa6DhSplits the <code>Fields</code> into its style and fields for further \xe2\x80\xa6CkHelper method for splitting this read/write object into \xe2\x80\xa6EeSplits this <code>Stream + Sink</code> object into separate <code>Sink</code> and \xe2\x80\xa60CnSplits an array at the given index, returning the separate \xe2\x80\xa6DkThe <code>split</code> function takes arbitrary data and a closure that \xe2\x80\xa6CkSplit midway into a new producer if possible, otherwise \xe2\x80\xa6CgReturns an iterator of spans of the haystack given, \xe2\x80\xa6DjSplits <code>n</code> permits from <code>self</code> and returns a new \xe2\x80\xa60DfSplits a <code>TcpStream</code> into a read half and a write half, \xe2\x80\xa6DgSplits a <code>UnixStream</code> into a read half and a write half, \xe2\x80\xa6DjSplits a single value implementing <code>AsyncRead + AsyncWrite</code> \xe2\x80\xa6ClReturns a stream of the contents of this reader split on \xe2\x80\xa60BhThe square root of <code>x</code> (f32).BiReturn the start position of this search.BcThe starting position of the match.BhThe start offset of the span, inclusive.CkCreate a new overlapping state that begins at the start \xe2\x80\xa6CfReturns the starting index of this window into the \xe2\x80\xa643211BfThe inclusive start of the byte range.CaProvides helpers for dealing with start state \xe2\x80\xa6CkThis method is called before beginning traversal of the \xe2\x80\xa60AfThe start byte offset.AhThe start of this range.22AoReturn the start of this range.0B`Start of byte range (inclusive).CdReturns the current state of this <code>Once</code>.ClReturn a reference to the NFA state corresponding to the \xe2\x80\xa6CiSets configuration for the child process\xe2\x80\x99s standard \xe2\x80\xa6CjThe handle for writing to the child\xe2\x80\x99s standard input \xe2\x80\xa6ChConstructs a new handle to the standard input of the \xe2\x80\xa6AmSteals a task from the queue.0AeStatements in a blockEcStores a <code>Shared</code> or <code>Owned</code> pointer into the atomic pointer.BmStores <code>val</code> into the atomic cell.BfTraits for pluggable LiteMap backends.DgDescribe a context in which to verify an <code>X509</code> certificate.DdThe type of binding which this <code>BindingInfo</code> will create.BoThe hyperbolic tangent of <code>x</code> (f32).CbProvide a timer to execute background HTTP2 tasks.BgSet the timer used in background tasks.0BaProvide a timer to be used for h211DgConvert <code>self</code> to big endian from the target\xe2\x80\x99s endianness.BnConverts the integer to a <code>BigNum</code>.EeConverts the value of <code>self</code> to an <code>i8</code>. If the value cannot beDbConvert <code>self</code> to little endian from the target\xe2\x80\x99s \xe2\x80\xa6EhConverts the value of <code>self</code> to a <code>u8</code>. If the value cannot be \xe2\x80\xa6AlReturns the event\xe2\x80\x99s token.CgTokens representing Rust punctuation, keywords, and \xe2\x80\xa6Di<code>tokio</code> runtime components integration for <code>hyper</code>.CgA runtime for writing reliable network applications \xe2\x80\xa6Db<code>async fn(Request) -&gt; Result&lt;Response, Error&gt;</code>DjCreates a new <code>Builder</code> initialized with a TRACE method and \xe2\x80\xa6BbLogs a message at the trace level.BgConstructs an event at the trace level.BkThe transition from this state to the next.ClReturns a copy of the network with the address truncated \xe2\x80\xa600ClRounds the number toward 0 to the closest integral value \xe2\x80\xa6AdRounds towards zero.BdReturn the integer part of a number.00AeULE impls for tuples.Cktype of hasher to use (default: type 6, but others have \xe2\x80\xa6ChGet the top level media type for this <code>Mime</code>.AgThe name of the digest.BkReturns the <code>Nid</code> of the digest.CfReturn the type of a PKCS#7 structure as an Asn1ObjectAlA type representing user ID.D`The bitwise or (<code>|</code>) of the bits in two flags values.0CkVisits the values representing the union, i.e., all the \xe2\x80\xa6AlTake the union of two groupsDgReturn an iterator over all values that are in <code>self</code> or \xe2\x80\xa6333333333333AmReturn the union of two sets.CkReturns a new set that is the union of this and the one \xe2\x80\xa6AiBuild a set from a union.CnUnion this character class with the given character class, \xe2\x80\xa6CjUnion this byte class with the given byte class, in place.CkReturns a new set of properties that corresponds to the \xe2\x80\xa64CeUnions the <code>other</code> sequence into this one.DkStrips the raw marker <code>r#</code>, if any, from the beginning of an \xe2\x80\xa6ClConverts a stream of pairs into a future, which resolves \xe2\x80\xa60CjUnzips the items of a parallel iterator into a pair of \xe2\x80\xa6DkReturns the upper bound of data the <code>Body</code> will yield before \xe2\x80\xa60CkTraits and types used for tracking the usage of generic \xe2\x80\xa6ClBundles the part of UTS 46 that makes sense to implement \xe2\x80\xa6BaGet the flags value of this flag.CkThe value which was not inserted, because the entry was \xe2\x80\xa6AnThe value portion of a header.BfTrie value associated with this range.CkA macro allowing for compile-time construction of valid \xe2\x80\xa6BhThe property value (which may be empty).ClBuilding blocks for deserializing basic values using the \xe2\x80\xa60CkThe Value enum, a loosely typed way of representing any \xe2\x80\xa6CnUsed when parsing <code>key = &quot;value&quot;</code> syntax.CgBorrows the syntax tree node from this punctuated pair.DhExecutes an implementation of <code>Visitor</code> in constant stack \xe2\x80\xa60CmSyntax tree traversal to walk a shared borrow of a syntax \xe2\x80\xa6EdConstructs a <code>SockAddr</code> with the family <code>AF_VSOCK</code> and the \xe2\x80\xa6DjCreates a <code>Waker</code> from an <code>Arc&lt;impl ArcWake&gt;</code>.0CnA multi-producer, multi-consumer channel that only retains \xe2\x80\xa6A`Width in pixels.DeImplementations of <code>io::Write</code> to transparently handle \xe2\x80\xa6CcEncode input and then write to the delegate writer.CkLocks with exclusive write access, blocking the current \xe2\x80\xa6DjTypes which operate over <code>Write</code> streams, both encoders and \xe2\x80\xa6CjConsume this builder, creating a writer encoder in the \xe2\x80\xa6DjCreates a future which will write bytes from <code>buf</code> into the \xe2\x80\xa6DhLocks this <code>RwLock</code> with exclusive write access, blocking \xe2\x80\xa6CiComputes hash for supplied data and stores results in \xe2\x80\xa6DkLocks this <code>RwLock</code> with exclusive write access, causing the \xe2\x80\xa6CjCreates a future that will open a file for writing and \xe2\x80\xa6BaSets the option for write access.CnWrites a buffer into this writer, returning how many bytes \xe2\x80\xa60DcWrites the bytes of <code>t</code> and then forgets <code>t</code>.DjImplement push-based <code>Write</code> trait for both compressing and \xe2\x80\xa6ChAdvertises which content types the client is able to \xe2\x80\xa6CfAlias for the associated type of <code>Abs</code>: \xe2\x80\xa6CaThe key used to encrypt or decrypt cipher blocks.AiAlways run on scope exit.Ag<code>&amp;&amp;</code>CeAn assignment expression: <code>a = compute()</code>.CgAn atomic pointer that can be safely shared between \xe2\x80\xa6AdThe bcrypt alphabet.CgThe encoding of some ASN.1 DER-encoded item is invalid.ChA bare function type: <code>fn(usize) -&gt; bool</code>.Ac<code>become</code>AjA big signed integer type.BmDynamically sized large number implementationClA binary operation: <code>a + b</code>, <code>a += b</code>.BmThe <code>&amp;</code> operator (bitwise and)BiThe <code>^</code> operator (bitwise xor)DhFor more info about <code>Budget</code>, please see the module-level \xe2\x80\xa6CnA trait for values that provide sequential write access to \xe2\x80\xa6DfBuffer type used by type which implements <code>BufferKindUser</code>.BhSink for the <code>buffer</code> method.ChA correctly sized stack allocation for the formatted \xe2\x80\xa6CgSafe API for formatting floating point numbers to text.0EaDerives optimized [<code>PartialEq</code>] and [<code>Eq</code>] implementations.CjUsed by the endpoint to indicate that the stream is no \xe2\x80\xa6BjEnable session caching on the client side.CnContains stored HTTP cookies previously sent by the server \xe2\x80\xa6DaThe <code>Choice</code> struct represents a choice for use in \xe2\x80\xa6CfA distribution to uniformly sample elements of a sliceBjStream for the <code>chunks</code> method.Da<code>Chunks</code> is an iterator that groups elements of an \xe2\x80\xa6CnParallel iterator over immutable non-overlapping chunks of \xe2\x80\xa6AcA symmetric cipher.BiRepresents a particular cipher algorithm.BhA Client to make outgoing HTTP requests.De<code>Cloned</code> is an iterator that clones the elements of an \xe2\x80\xa6B`The channel is empty and closed.BcInclusive at the beginning and end.CkThe semaphore has been closed and cannot issue new permits.ClThe receive half of the channel was explicitly closed or \xe2\x80\xa60ChThere are no more active senders implying no further \xe2\x80\xa60CnThe send half of the channel was dropped without sending a \xe2\x80\xa6ClThe <code>Taker</code> has canceled its interest in a value.CeA previous version of the ordering, for compatibilityBjFuture for the <code>concat</code> method.DgDefines <code>GenericSequence</code>s which can be joined together, \xe2\x80\xa6BgA concatenation of regular expressions.AoA concatenation of expressions.1CiThe configuration for a packed multiple pattern searcher.BcThe config type used by this engineChThe minimal level of configuration that engines must \xe2\x80\xa6CoAn object describing the configuration of a <code>Regex</code>.CmThe configuration used to determine a DFA\xe2\x80\x99s start state \xe2\x80\xa6CkA common set of configuration options that apply to the \xe2\x80\xa6BoThe configuration used for building a lazy DFA.CaThe configuration used for compiling a dense DFA.CcThe configuration used for building a one-pass DFA.CcThe configuration used for a Thompson NFA compiler.CjThe configuration used for building a <code>PikeVM</code>.CjThe configuration used for building a bounded backtracker.De<code>Copied</code> is an iterator that copies the elements of an \xe2\x80\xa6oCoptic calendarDjA <code>Cursor</code> wraps an in-memory buffer and provides it with a \xe2\x80\xa6CjA cheaply copyable cursor into a <code>TokenBuffer</code>.AnAn unspecified error occurred.fDELETECgConvenience wrapper trait covering functionality of \xe2\x80\xa6AjA calculated digest value.1n<code>$</code>CgSpecification of the communication domain for a socket.o<code>..</code>BkAlias to make it easy to multiply by 2. \xe2\x80\xa6AnReference to <code>Dsa</code>.BbObject representing DSA signature.CkIndicates expectations that need to be fulfilled by the \xe2\x80\xa6FdThe enum <code>Either</code> with variants <code>Left</code> and <code>Right</code> is a general \xe2\x80\xa6ClCombines two different futures, streams, or sinks having \xe2\x80\xa6EeSum type with two cases: <code>Left</code> and <code>Right</code>, used if a body \xe2\x80\xa621CgCombine two different service types into a single type.DcAn <code>Engine</code> provides low-level encoding and decoding \xe2\x80\xa6BaA collection of readiness events.DkAn <code>if</code> expression with an optional <code>else</code> block: \xe2\x80\xa6Ac<code>extern</code>BiFailed to decompress due to invalid data.ClSink that clones incoming items and forwards them to two \xe2\x80\xa6DhEquivalent to <code>syn::Fields</code>, but replaces the AST element \xe2\x80\xa6DoA list of <code>Key</code>-<code>Value</code> pairs representing functional \xe2\x80\xa6BmData stored within an enum variant or struct.kFields onlyBjStream for the <code>filter</code> method.E`<code>Filter</code> takes a predicate <code>filter_op</code> and filters out \xe2\x80\xa6CeA forward substring searcher using the Rabin-Karp \xe2\x80\xa6CeAn architecture independent \xe2\x80\x9cpacked pair\xe2\x80\x9d finder.CfA forward substring searcher that uses the Two-Way \xe2\x80\xa6CjA forward substring searcher using the Shift-Or algorithm.CgA \xe2\x80\x9cpacked pair\xe2\x80\x9d finder that uses 128-bit vector \xe2\x80\xa6CgA \xe2\x80\x9cpacked pair\xe2\x80\x9d finder that uses 256-bit vector \xe2\x80\xa6CiA single substring searcher fixed to a particular needle.CiPending input is processed and pending output is flushed.0CgAttempt to flush the remaining data and end the stream.CcTry to flush everything and end the deflate stream.CjThe type of folder that this consumer can be converted \xe2\x80\xa6DkThe <code>Folder</code> trait encapsulates the standard fold operation. \xe2\x80\xa6Bl(<code>Cf</code>) A format control character0EfA unified <code>Stream</code> and <code>Sink</code> interface to an underlying I/O \xe2\x80\xa6AjA not-yet-completed future0CnThe <code>Future</code> returned by this <code>Service</code>.AjThe future response value.0C`The future of the <code>Service</code> instance.CaThe future that eventually produces the transport1DdThe <code>Future</code> type returned by <code>Policy::retry</code>.CnThe future associated with each backoff. This usually will \xe2\x80\xa64CmThe search, based on heuristics, determined that it would \xe2\x80\xa6BnA view to all values stored in a single entry.Ae<code>HTTP/2.0</code>Ae<code>HTTP/3.0</code>CfPerforms both compressed and uncompressed conversions.AfHandle to the runtime.BlRepresents an in-progress CRC32 computation.BkProvides message digest (hash) computation.AkRepresents a parsed header.AkTraditional Hebrew calendarAdDeprecated property.BnProtocol corresponding to <code>ICMPv4</code>.BnProtocol corresponding to <code>ICMPv6</code>.B`Ignore the CRL nextUpdate field.DhThis is a <code>VarZeroVecFormat</code> that stores u8s in the index \xe2\x80\xa6oIndian calendarCiJSON input source that reads from a std::io input stream.Dd<code>no_std</code> implementation of <code>std::net::IpAddr</code>.FlA <strong>type operator</strong> that returns <code>True</code> if <code>Self &lt; Rhs</code>, otherwise \xe2\x80\xa6AmA free-standing function: \xe2\x80\xa6BdInitialization vector size in bytes.AjKelvin as temperature unitAb<code>&lt;-</code>Bb423 Locked [RFC4918, Section 11.3]AlReturn <code>log2(e)</code>.CmThe receiver lagged too far behind. Attempting to receive \xe2\x80\xa6ClThe receiver lagged too far behind and has been forcibly \xe2\x80\xa6Bk<code>GenericArray</code> associated lengthCfAlias for the associated type of <code>Len</code>: \xe2\x80\xa6Cc(<code>L</code>) The union of all letter categoriesChAn integer literal: <code>1</code> or <code>1u16</code>.CeA UTF-8 string literal: <code>&quot;foo&quot;</code>.DdA core struct representing a <code>Unicode Locale Identifier</code>.CdA locked value acquired from a <code>TryLock</code>.Dm<code>GenericSequence</code> that has one more element than <code>Self</code>BkFuture for the <code>map_err</code> method.BkStream for the <code>map_err</code> method.CeBody returned by the <code>map_err</code> combinator.ChService returned by the <code>map_err</code> combinator.AdMapped sequence typeDg<code>MaxLen</code> is an iterator that imposes a maximum length on \xe2\x80\xa6CgA struct or tuple struct field accessed in a struct \xe2\x80\xa6CjAn iterator over all occurrences of a single byte in a \xe2\x80\xa6AiThe Request Method (VERB)mMetric SystemDg<code>MinLen</code> is an iterator that imposes a minimum length on \xe2\x80\xa6CgConfiguration of a <code>sendmsg(2)</code> system call.DjFused multiply-add. Computes <code>(self * a) + b</code> with only one \xe2\x80\xa6CmDon\xe2\x80\x99t add padding when encoding, and require no padding \xe2\x80\xa6CfAlias for the associated type of <code>Neg</code>: \xe2\x80\xa6CeFuture for the <code>Peekable::next_if</code> method.CmCSS level 3 line-break=normal, e.g. treat CJ as ID, break \xe2\x80\xa6CgCSS lev 3 word-break=normal, normal script/language \xe2\x80\xa6BbNotifies a single task to wake up.CfGeneric trait for types implementing basic numeric \xe2\x80\xa6DeThe trait for <code>Num</code> types which also implement numeric \xe2\x80\xa6Cc(<code>N</code>) The union of all number categoriesCiRepresents a JSON number, whether integer or floating \xe2\x80\xa6000BhIndicates where a fetch originates from.AiRepresents a JSON object.0BkFuture for the <code>ok_into</code> method.D`An opaque type used to define <code>ForeignTypeRef</code> types.0CmA distribution to sample floating point numbers uniformly \xe2\x80\xa6DjThe input contained an <code>Option&lt;T&gt;</code> that was not expected.0BkFuture for the <code>or_else</code> method.BkStream for the <code>or_else</code> method.CiOutput array of <code>OutputSizeUser</code> implementors.0A`Resulting lengthBoResulting sequence formed by the concatenation.BgThe result after applying the operator.CiThe resulting type after applying the fused multiply-add.1CmThe type of value returned by this callback. Analogous to \xe2\x80\xa6AnThe result of visiting an AST.AnThe result of visiting an HIR.BbShould always be <code>Self</code>AcThe absolute value.BaThe result of the exponentiation.ClThe result of the comparison. It should only ever be one \xe2\x80\xa6BlThe length as a type-level unsigned integer.BaThe type of the result of the sumBeThe type of the result of the productBfThe type of the result of the divisionDaThe type of the minimum of <code>Self</code> and <code>Rhs</code>DaThe type of the maximum of <code>Self</code> and <code>Rhs</code>DdThe type representing either <code>True</code> or <code>False</code>00000BfThe result of the integer square root.BkThe result of the integer binary logarithm.AlThe greatest common divisor.FlThis type MUST be <code>Self</code> with the <code>&#39;static</code> replaced with <code>&#39;a</code>, \xe2\x80\xa6CkDomain for low-level packet interface, corresponding to \xe2\x80\xa6CiHTTP/1.0 header usually used for backwards compatibility.BjAn iterator over the parameters of a MIME.CeA tag type indicating that a key only has parameters.AkA thread parking primitive.BmA convenience parser for regular expressions.AlA regular expression parser.CnParser that can parse Rust tokens into a particular syntax \xe2\x80\xa6EbA literal in place of an expression: <code>1</code>, <code>&quot;foo&quot;</code>.BkPermits to send one value into the channel.CjPrioritize keeping natural phrases (of multiple words) \xe2\x80\xa6CgA virtual machine for executing regex searches with \xe2\x80\xa6CmPinyin ordering for Latin and for CJK characters (used in \xe2\x80\xa6o<code>+=</code>CkA \xe2\x80\x9cretry policy\xe2\x80\x9d to classify if a request should be \xe2\x80\xa6BmFuture for the <code>poll_fn</code> function.BmStream for the <code>poll_fn</code> function.BkExtracts only prefix literals from a regex.CdA tag type indicating that a key only has public \xe2\x80\xa6BlA public visibility level: <code>pub</code>.Ab<code>-&gt;</code>DkA random value constructed from a <code>SecureRandom</code> that hasn\xe2\x80\x99\xe2\x80\xa6EcA <code>Buf</code> adapter which implements <code>io::Read</code> for the inner \xe2\x80\xa6fReaderDhA read-only, forward-only cursor into the data in an <code>Input</code>.DfImplements the <code>Read</code> API around an <code>Operation</code>.AcHTTP/2 error codes.BcThe \xe2\x80\x9cpayload\xe2\x80\x9d of a log message.BcA set of fields recorded by a span.0Af<code>ref mut x</code>DeThe trait for <code>Num</code> references which implement numeric \xe2\x80\xa6GfA region subtag (examples: <code>&quot;US&quot;</code>, <code>&quot;CN&quot;</code>, <code>&quot;AR&quot;</code> etc.)ChA future which sends its output to the corresponding \xe2\x80\xa6CnAn renamed identifier imported by a <code>use</code> item: \xe2\x80\xa6BnReader for the <code>repeat()</code> function.BlStream for the <code>repeat</code> function.ChIterator adaptor for the <code>repeat()</code> function.CkAn array literal constructed from one repeated element: \xe2\x80\xa6CkAn async reader which yields one byte over and over and \xe2\x80\xa6Bc<code>Result&lt;T, Error&gt;</code>CnAn alias of <code>Result</code> specific to attribute parsing.DkA <code>Result</code> typedef to use with the <code>http::Error</code> typeAoA Result of any parsing action.CiResult type often returned from methods that can have \xe2\x80\xa6CfA typedef of the result-type returned by many methods.CiThe type of result that this consumer will ultimately \xe2\x80\xa6CnThe type of result that will ultimately be produced by the \xe2\x80\xa6EcAlias for a <code>Result</code> with the error type <code>serde_json::Error</code>.0AkThe result of a Syn parser.0CmA <code>return</code>, with an optional value to be returned.Ac<code>return</code>AmReference to <code>RSA</code>AdA reader-writer lock0BcAn asynchronous reader-writer lock.CnContains information about the software used by the origin \xe2\x80\xa6BjEnable session caching on the server side.BcSHA-256 as specified in FIPS 180-4.BcSHA-384 as specified in FIPS 180-4.BcSHA-512 as specified in FIPS 180-4.AnReturn <code>sqrt(2.0)</code>.BoType corresponding to <code>SOCK_STREAM</code>.AmQUIC sample for new key masksBhRepresents the scheme component of a URIEnA script subtag (examples: <code>&quot;Latn&quot;</code>, <code>&quot;Arab&quot;</code>, etc.)AkEnumerated property Script.BhSpecial collation type for string searchBhSecond part of the resulting split arrayBnFuture for the <code>select()</code> function.BnStream for the <code>select()</code> function.BoThe transmission end of a bounded mpsc channel.CgA means of transmitting a single value to another task.AlSending end of an Unix pipe.CeSends values to the associated <code>Receiver</code>.0CfSends a value to the associated <code>Receiver</code>.CcSending-half of the <code>broadcast</code> channel.AkWriting end of a Unix pipe.AnSender of the simplex channel.DhA <strong>type operator</strong> that, when implemented for unsigned \xe2\x80\xa6CfAn object which calculates a SHA224 hash of some data.CfAn object which calculates a SHA256 hash of some data.CfAn object which calculates a SHA384 hash of some data.CfAn object which calculates a SHA512 hash of some data.CaA pointer to an object protected by the epoch GC.BjFuture for the <code>shared</code> method.DiA <code>MakeService</code> that produces services by cloning an inner \xe2\x80\xa6CfAlias for the associated type of <code>Shl</code>: \xe2\x80\xa6CiAn listener for receiving a particular type of OS signal.CnUseful functions for signed numbers (i.e. numbers that can \xe2\x80\xa6G`The input contained a signed integer <code>i8</code>, <code>i16</code>, <code>i32</code> or <code>i64</code> \xe2\x80\xa60CgA type which computes cryptographic signatures of data.BeOwned wrapper around a system socket.DbAn event source that may be registered with <code>Registry</code>.CkA state with possibly many transitions represented in a \xe2\x80\xa6BnA splicing iterator for <code>IndexMap</code>.BnA splicing iterator for <code>IndexSet</code>.DiYields at most <code>N</code> spans delimited by a regular expression \xe2\x80\xa6BdAlias to make it easy to square. \xe2\x80\xa6BaReference to an <code>Ssl</code>.o<code>*=</code>CiA static item: <code>static BIKE: Shed = Shed(42)</code>.EcA foreign static item in an <code>extern</code> block: <code>static ext: u8</code>.Ac<code>static</code>CgPossible status results of compressing some data or \xe2\x80\xa6B`Invalid byte in Response status.BfThe result of a successful parse pass.BeDescribes the result of an operation.BlA strong, fast (amortized), non-portable RNGCcA handle to the standard error stream of a process.CdA handle to the standard output stream of a process.Ef<code>StepBy</code> is an iterator that skips <code>n</code> elements between each \xe2\x80\xa6BkA stream of values produced asynchronously.0AeGeneral stream error.CbCSS level 3 line-break=strict, e.g. treat CJ as NSAiRepresents a JSON string.0CnPinyin ordering for Latin, stroke order for CJK characters \xe2\x80\xa6CoA struct literal expression: <code>Point { x: 1, y: 1 }</code>.CoA struct definition: <code>struct Foo&lt;A&gt; { x: A }</code>.DfA struct or struct variant pattern: <code>Variant { x, y, .. }</code>.Ac<code>struct</code>D`A single item used in a list of <code>Private</code> extensions.AaA generic subtag.BkExtracts only suffix literals from a regex.ChExchange neigboring ranges of bits of the specified sizeCc(<code>S</code>) The union of all symbol categoriesClThe error was caused by input that was not syntactically \xe2\x80\xa6gTLSv1.1gTLSv1.2gTLSv1.3CaThe TLS 1.0 protocol is insecure. Don\xe2\x80\x99t use it.AeThe TLS 1.1 protocol.AeThe TLS 1.2 protocol.CaThe TLS 1.3 protocol. Not supported on macOS/iOS.BkFuture for the <code>try_all</code> method.BkFuture for the <code>try_any</code> method.AmTunnel Proxy via HTTP CONNECTAc<code>typeof</code>BlStream for the <code>unfold</code> function.BjSink for the <code>unfold</code> function.CmPinyin ordering for Latin, Unihan radical-stroke ordering \xe2\x80\xa6CnUnpark the thread and continue scanning the list of parked \xe2\x80\xa6BmAn unsafe block: <code>unsafe { ... }</code>.Ac<code>unsafe</code>BoTypes which consume data with byte granularity.Df<code>Update</code> is an iterator that mutates the elements of an \xe2\x80\xa6oA vacant entry.000nA vacant entryBkVacant slot (no equivalent key in the map).0oA vacant Entry.DfAn iterator over the values of a <code>HashMap</code> in arbitrary \xe2\x80\xa6Bf<code>HeaderMap</code> value iterator.ChAn iterator over the values of an <code>IndexMap</code>.BnAn iterator over a serde_json::Map\xe2\x80\x99s values.BgCustom derive for [<code>VarULE</code>]CmVariable-width, byte-aligned data that can be cast to and \xe2\x80\xa6DjFull docs for this proc macro can be found on the <code>zerovec</code> \xe2\x80\xa6AbBounds on a weightBlAn owned window around an underlying buffer.CmA vector composed of four words; depending on their size, \xe2\x80\xa6oA worker queue.EgA <code>BufMut</code> adapter which implements <code>io::Write</code> for the inner \xe2\x80\xa6DgImplements the <code>Write</code> API around an <code>Operation</code>.ChX25519 (ECDH using Curve25519) as described in RFC 7748.AbHexadecimal digitsAh<code>[0-9A-Fa-f]</code>ClPinyin ordering for Latin, zhuyin order for Bopomofo and \xe2\x80\xa6CdA zero-sized field indicating the alignment we want.CdAccept the next incoming request on this connection.BeAccepts a new <code>TcpStream</code>.CcAccepts a new incoming connection to this listener.AjInitiates a TLS handshake.BfInitiates a server-side TLS handshake.AlSee <code>Ssl::accept</code>C`Initiates a server-side TLS session on a stream.2CdAccept a new incoming connection from this listener.CeAccepts a new incoming connection from this listener.6AoInverse hyperbolic cosine (f32)CfThis corresponds to <code>OCSP_request_add0_id</code>.BaAdler-32 checksum implementation.DbThe PKIX <code>AlgorithmIdentifier</code> type, and common values.DhReturns an <code>Interest</code> indicating the subscriber is always \xe2\x80\xa60ClThe number of bytes that have been used to calculate the \xe2\x80\xa6BfYields the trust anchor for this path.Algithub\xe2\x80\x82crates-io\xe2\x80\x82docs-rsCkConstruct an ad-hoc error from a string or existing non-\xe2\x80\xa6CnReturns a new array with the given element appended to the \xe2\x80\xa6BfInserts a key-value pair into the map.B`Insert the value into the entry.EeMoves all key-value pairs from <code>other</code> into <code>self</code>, leaving \xe2\x80\xa6FbMoves all values from <code>other</code> into <code>self</code>, leaving <code>other</code> empty.CaFor use by <code>ToTokens</code> implementations.CjMoves all elements from other into self, leaving other \xe2\x80\xa6FcMoves all the elements of <code>other</code> into <code>self</code>, leaving <code>other</code> \xe2\x80\xa6BdSets the option for the append mode.CkReturns a new <code>InBuffer</code> around the given slice.ClReturns a new <code>OutBuffer</code> around the given slice.10ChIf this unit is an \xe2\x80\x9cend of input\xe2\x80\x9d sentinel, then \xe2\x80\xa6DkIf the <code>Value</code> is a number, represent it as f64 if possible. \xe2\x80\xa6CjRepresents the number as f64 if possible. Returns None \xe2\x80\xa6DjReturn the internal value as a <code>i32</code>. This is guaranteed to \xe2\x80\xa60DkReturn the internal <code>u32</code> of this small index represented as \xe2\x80\xa6BeReturn the internal value as a i32\xe2\x80\xa60DcIf the <code>Value</code> is an integer, represent it as i64 if \xe2\x80\xa6DdIf the <code>Number</code> is an integer, represent it as i64 if \xe2\x80\xa6EhConverts from <code>Override&lt;T&gt;</code> to <code>Override&lt;&amp;mut T&gt;</code>.FfConvert <code>&amp;mut Either&lt;L, R&gt;</code> to <code>Either&lt;&amp;mut L, &amp;mut R&gt;</code>.BgAccess the unfilled part of the buffer.1CdReturns a pointer to the objects held by the vector.BnReturn a raw pointer to the vector\xe2\x80\x99s buffer.BnReturn a raw pointer to the string\xe2\x80\x99s buffer.ChReturns a raw pointer to the underlying data in this \xe2\x80\xa6BkReturns a raw pointer to the wrapped value.000AgConvert to raw pointer.BkReturns a pointer to the raw OpenSSL value.CbReturns a pointer to the underlying OpenSSL value.BoReturns a raw pointer to the vector\xe2\x80\x99s buffer.BeReturns a raw pointer to the address.ChConverts the pointer to a raw pointer (without the tag).CgReturns the raw OpenSSL value represented by this type.ChReturn the integer representation of a <code>Nid</code>.CjReturns the integer representation of the <code>Id</code>.CkReturns the integer representation of <code>Padding</code>.DaReturns the integer representation of <code>SrtpProfileId</code>.4444DfReturn the integer representation of an <code>X509VerifyResult</code>.5BdConverts the pointer to a reference.G`Creates a new <code>Data&lt;&amp;&#39;a V, &amp;&#39;a F&gt;</code> instance from <code>Data&lt;V, F&gt;</code>.EdConverts from <code>Override&lt;T&gt;</code> to <code>Override&lt;&amp;T&gt;</code>.EjConvert <code>&amp;Either&lt;L, R&gt;</code> to <code>Either&lt;&amp;L, &amp;R&gt;</code>.BnConvert this finder into its borrowed variant.01ChCheaply return a borrowed version of this dense DFA. \xe2\x80\xa6CiCheaply return a borrowed version of this sparse DFA. \xe2\x80\xa6C`Borrows as an <code>Option&lt;&amp;U&gt;</code>.CcObtain this as an <code>Option&lt;&amp;U&gt;</code>DkCheaply convert to a <code>&amp;std::process::Command</code> for places \xe2\x80\xa6ClReturn a string slice of the whole <code>ArrayString</code>.DlCreate a <code>&amp;str</code> from the symbols in the <code>Alphabet</code>AjGet the ident as a string.BkReturns a str representation of the header.ChReturns a <code>str</code> representation of the header.CcReturn a &amp;str representation of the HTTP methodD`Returns a &amp;str representation of the <code>StatusCode</code>BnReturns the port number as a <code>str</code>.BlReturn a str representation of the authorityCaReturns the path and query as a string component.BiReturn a str representation of the scheme7BdView the hostname as a string slice.ClA helper function for displaying as a <code>&amp;str</code>.00000000000000000000000DjReturns this <code>DataMarkerAttributes</code> as a <code>&amp;str</code>.ClReturns the string representation of the <code>Level</code>.DbReturns the string representation of the <code>LevelFilter</code>.CdGet the value of this <code>Name</code> as a string.DfIf the <code>Value</code> is a String, returns the associated str. \xe2\x80\xa633DkReturns the <code>u16</code> corresponding to this <code>StatusCode</code>.BnReturns the port number as a <code>u16</code>.DjReturn the internal value as a <code>u32</code>. This is guaranteed to \xe2\x80\xa60DhReturns the <code>u32</code> corresponding to this <code>StreamId</code>DeReturn the internal <code>u32</code> of this small index. This is \xe2\x80\xa622DjReturn the internal value as a <code>u64</code>. This is guaranteed to \xe2\x80\xa60DhReturn this small index as a <code>u64</code>. This is guaranteed to \xe2\x80\xa611DcIf the <code>Value</code> is an integer, represent it as u64 if \xe2\x80\xa6DdIf the <code>Number</code> is an integer, represent it as u64 if \xe2\x80\xa6AmInverse hyperbolic sine (f32)DkReturns <code>true</code> if the reader is at the end of the input, and \xe2\x80\xa6AgArctangent of y/x (f32)B`Inverse hyperbolic tangent (f32)mAtomic types.CgCorrect, fast, and configurable base64 decoding and \xe2\x80\xa6AhBase64 encoding support.DoReturns the intersection of <code>self</code> and <code>rhs</code> as a new \xe2\x80\xa6CdReturns the set intersection, cloned into a new set.DeThe bitwise and (<code>&amp;</code>) of the bits in two flags values.00000000000EgReturns the symmetric difference of <code>self</code> and <code>rhs</code> as a new \xe2\x80\xa6CkReturns the set symmetric-difference, cloned into a new \xe2\x80\xa6DfThe bitwise exclusive-or (<code>^</code>) of the bits in two flags \xe2\x80\xa600000000000DfImmutably borrows from an owned value. See <code>Borrow::borrow</code>DmProduce a borrowed <code>DnsName</code> from this owned <code>DnsName</code>.CdReturns a reference to the most recently sent value.CcReturns a reference to the most recently sent valueCnConvert the owned representation of this revoked cert to a \xe2\x80\xa6mTrait aliasesCoTrait and lifetime bounds (<code>Clone+Send+&#39;static</code>)CkParse a set of curly braces and expose their content to \xe2\x80\xa6ClThis helper function is used to \xe2\x80\x9cconnect\xe2\x80\x9d a parallel \xe2\x80\xa6CnA retry \xe2\x80\x9cbudget\xe2\x80\x9d for allowing only a certain amount of \xe2\x80\xa6CdReturns a reference to the internally buffered data.0DjReturns a reference to <code>buf_writer</code>\xe2\x80\x99s internally buffered \xe2\x80\xa6BmAdds a fixed-size buffer to the current sink.ChA stably addressed token buffer supporting efficient \xe2\x80\xa633AjBuilds the PKCS#12 object.BkBorrows a stream, rather than consuming it.0DbEquivalent to C\xe2\x80\x99s <code>void</code> type when used as a pointer.DhCancel the <code>CancellationToken</code> and all child tokens which \xe2\x80\xa6CkSignal to the <code>Giver</code> that the want is canceled.ClA macro for defining <code>#[cfg]</code> if-else statements.CdThe main macro provided by this crate. See crate \xe2\x80\xa6AlUniformly sample one element000CkAn adaptor for chunking up items of the stream inside a \xe2\x80\xa60BmSplits an iterator up into fixed-size chunks.AbSymmetric ciphers.BmClient implementation of the HTTP/2 protocol.kHTTP ClientAeHTTP client utilitiesFfMaps an <code>Either&lt;&amp;mut L, &amp;mut R&gt;</code> to an <code>Either&lt;L, R&gt;</code> by \xe2\x80\xa6FjMaps an <code>Either&lt;&amp;L, &amp;R&gt;</code> to an <code>Either&lt;L, R&gt;</code> by cloning the \xe2\x80\xa610CjCreates an iterator which clones all of its elements.  \xe2\x80\xa6BhCompletes when the receiver has dropped.0CiA future which completes when the number of Receivers \xe2\x80\xa6BjCompletes when all receivers have dropped.CoWaits for the associated <code>Receiver</code> handle to close.CjThe approximate column number, starting at <code>1</code>.ChOne-based column number at which the error was detected.CnConcatenate all items of a stream into a single extendable \xe2\x80\xa60BdConcatenate, or join, two sequences.AoCreate a \xe2\x80\x9cconcat\xe2\x80\x9d AST item.CcReturns the concatenation of the given expressions.DoReturns a <code>TinyAsciiStr&lt;Q&gt;</code> with the concatenation of this \xe2\x80\xa6CnA convenience function for calling <code>Config::new()</code>.BcReturns the config for this engine.ChReturn a default configuration for a <code>Regex</code>.CfReturn a new default dense DFA compiler configuration.BiReturn a default configuration for a DFA.CfReturn a default configuration for a <code>DFA</code>.CgReturn a default configuration for an <code>NFA</code>.CiReturn a default configuration for a <code>PikeVM</code>.DeReturn a default configuration for a <code>BoundedBacktracker</code>.DdGets the value for the <code>SO_COOKIE</code> option on this socket.FfMaps an <code>Either&lt;&amp;mut L, &amp;mut R&gt;</code> to an <code>Either&lt;L, R&gt;</code> by \xe2\x80\xa6FjMaps an <code>Either&lt;&amp;L, &amp;R&gt;</code> to an <code>Either&lt;L, R&gt;</code> by copying the \xe2\x80\xa610CjCreates an iterator which copies all of its elements.  \xe2\x80\xa6FdCreates a new <code>Nid</code> for the <code>oid</code> with short name <code>sn</code> and long \xe2\x80\xa6CkCreates an OCSP response from the status and optional body.B`Opens a file in write-only mode.CgCreates the specified directory with the configured \xe2\x80\xa6BhSets the option for creating a new file.BfPrepare a dictionary to compress data.BaWrap <code>ZSTD_createCCtx</code>AoCreates a new decoding context.2CmCompletes when a \xe2\x80\x9cctrl-c\xe2\x80\x9d notification is sent to the \xe2\x80\xa6BdGets a cursor into the current trie.CiProvides low-level access to the token representation \xe2\x80\xa6BjTypes for walking stepwise through a trie.22BjCreates a new error with a custom message.CiReturns a new, empty DataError with kind Custom and a \xe2\x80\xa6BhSets the salt length to the given value.CkRaised when there is general error when deserializing a \xe2\x80\xa6DjUsed when a <code>Serialize</code> implementation encounters any error \xe2\x80\xa610CbDocumentation on implementing custom VarULE types.CeDecode base64 using the <code>STANDARD</code> engine.BmDecode the input into a new <code>Vec</code>.CjAttempts to decode a frame from the provided buffer of \xe2\x80\xa6B`Returns the degree of the curve.DkCreates a new <code>Builder</code> initialized with a DELETE method and \xe2\x80\xa6DhFunctions to derive <code>darling</code>\xe2\x80\x99s traits from well-formed \xe2\x80\xa6AiShared secret derivation.ClDerives a shared secret between the two keys, writing it \xe2\x80\xa6BiDerives a shared secret between two keys.DkFills <code>out</code> with the key derived using PBKDF2 with the given \xe2\x80\xa6DfGets the value for the <code>SO_BINDTODEVICE</code> option on this \xe2\x80\xa600CnThis crate provides traits which describe functionality of \xe2\x80\xa6BbCompute hash of <code>data</code>.AiThe signature\xe2\x80\x99s digest.CeReturns a digest of the DER representation of the \xe2\x80\xa6BlSHA-2 and the legacy SHA-1 digest algorithm.DbReturns the digest of <code>data</code> using the given digest \xe2\x80\xa64ClThe number of digits that must be used with this literal \xe2\x80\xa6CkReturns stored cancellation token and removes this drop \xe2\x80\xa60EhReturns the <code>Domain</code> of this socket by checking the <code>SO_DOMAIN</code>\xe2\x80\xa6BmReturns this address\xe2\x80\x99s <code>Domain</code>.DkCreate a new pair of <code>DuplexStream</code>s that act like a pair of \xe2\x80\xa6C`Generates a new EC key using the provided curve.CbReturns a copy of the internal elliptic curve key.FdThe enum <code>Either</code> with variants <code>Left</code> and <code>Right</code> is a general \xe2\x80\xa6CnApply one of two functions depending on contents, unifying \xe2\x80\xa60AoModule defining an Either type.BbTypes to enable polymorphic carts.CmAdds this future to the list of futures that are ready to \xe2\x80\xa60DkEncode arbitrary octets as base64 using the <code>STANDARD</code> engine\xe2\x80\xa6DkEncode arbitrary octets as base64 using the provided <code>Engine</code>\xe2\x80\xa6BiEncodes a frame into the buffer provided.CfProvides the Engine abstraction and out of the box \xe2\x80\xa6CkReturn early with an error if a condition is not satisfied.BiErrors related to parsing of Preferences.B`Returns the errors in the stack.CeProvides convenience routines for escaping raw bytes.DdEscapes all regular expression meta characters in <code>text</code>.CjCalculates 10 raised to the power of <code>x</code> (f32).DkReturns <code>e^(self) - 1</code> in a way that is accurate even if the \xe2\x80\xa60AjThe HKDF-Expand operation.DcReturns the contained value, consuming the <code>self</code> value.BjExponential, base <em>e</em>, of x-1 (f32)AhExpose the random value.ChAdd the given iterator of patterns to this set to match.CbExtend the <code>ArrayVec</code> with an iterator.ClInserts all new key-values from the iterator to existing \xe2\x80\xa600CoExtends <code>self</code> with another <code>Extensions</code>.EdExtend a <code>HeaderMap</code> with the contents of another <code>HeaderMap</code>.ClExtends the preferences with the values from another set \xe2\x80\xa6ChExtend the map with all key-value pairs in the iterable.0D`The bitwise or (<code>|</code>) of the bits in each flags value.00000000000BkExtend this literal with the literal given.B`Returns this address\xe2\x80\x99s family.AoFanout items to multiple sinks.CnThe key-value pairs present in this locale extension, with \xe2\x80\xa6AnContent stored in the variant.ClReturns the names of the fields on the described span or \xe2\x80\xa6DfReturns an iterator over the set of values on this <code>Event</code>.CjReturns the set of all fields defined by this span\xe2\x80\x99s \xe2\x80\xa6210CjGet a slice of the buffer that has been filled in with \xe2\x80\xa6CkReturns a shared reference to the filled portion of the \xe2\x80\xa6CkFilters the values produced by this stream according to \xe2\x80\xa60DkApplies <code>filter_op</code> to each item of this iterator, producing \xe2\x80\xa6DiFilter the bindings created by this <code>Variant</code> object. This \xe2\x80\xa6DkFilter the bindings created by this <code>Structure</code> object. This \xe2\x80\xa6CnEncode all remaining buffered data and write it, including \xe2\x80\xa6DgStop accumulating errors, producing <code>Ok</code> if there are no \xe2\x80\xa6CbConsumes this encoder, flushing the output stream.0CiFinish encoding this stream, returning the underlying \xe2\x80\xa6CbConsumes this decoder, flushing the output stream.022CnIf this serializer was constructed with a string, take and \xe2\x80\xa6CgReturns the hash of the data written and resets the \xe2\x80\xa6AmReturns the hash of the data.0000EgAll implementors of <code>Visitor</code> must provide a <code>finish</code> method, \xe2\x80\xa60CkFinalizes the digest calculation and returns the digest \xe2\x80\xa6CeReturns the hash value for the values written so far.ChFinishes the operation, writing any footer if necessary.BcReturn the inner <code>Read</code>.0Bo<strong>Required</strong>: Finishes the stream.A`Ends the stream.ChA DEFLATE-based stream compression/decompression librarykFloor (f32)DcDrops this handle <em>without</em> canceling the underlying future.DhForgets the permit <strong>without</strong> releasing it back to the \xe2\x80\xa60CmDestroys the write half, but don\xe2\x80\x99t close the write half \xe2\x80\xa60ClPrint an integer into this buffer and return a reference \xe2\x80\xa6CmPrint a floating point number into this buffer and return \xe2\x80\xa60EbProvides a <code>Stream</code> and <code>Sink</code> interface for reading and \xe2\x80\xa60D`Converts <code>self</code> into an immutable <code>Bytes</code>.hFutures.AdAsynchronous values.CmAn extension trait for Futures that provides a variety of \xe2\x80\xa6lFuture types000DdBinary search the map with <code>predicate</code> to find a key, \xe2\x80\xa6CcGets a signed 8 bit integer from <code>self</code>.00BnReturns the error if the error is an io::ErrorCfGets an unsigned 8 bit integer from <code>self</code>.00CiLook up the canonical combining class for a scalar value.CcWhether this operation was applied greedily or not.ChWhether this repetition operator is greedy or not. A \xe2\x80\xa6AiHandles a possible error.EaCreate an <code>AbortHandle</code> from the given <code>AbortRegistration</code>.BlReturns a handle to the runtime\xe2\x80\x99s spawner.BjRepresents the <code>SIGHUP</code> signal.D`Gets a platform-independent hash of a <code>DataMarkerId</code>.ClReturns a reference to the map\xe2\x80\x99s <code>BuildHasher</code>.ClReturns a reference to the set\xe2\x80\x99s <code>BuildHasher</code>.CkReturn a reference to the map\xe2\x80\x99s <code>BuildHasher</code>.CkReturn a reference to the set\xe2\x80\x99s <code>BuildHasher</code>.CmReturns the header associated with this stream, if it was \xe2\x80\xa6CnReturns the current header associated with this stream, if \xe2\x80\xa6BoReturns the header associated with this stream.CfReturns the header associated with the current member.32AaHTTP header typesBiAppends a header to this request builder.BjAppends a header to this response builder.AaHeight in pixels.CaA module for building and searching with lazy \xe2\x80\xa6CkToggle whether the hybrid NFA/DFA (also known as the \xe2\x80\x9c\xe2\x80\xa6ClStructure used in SIOCGIFCONF request.  Used to retrieve \xe2\x80\xa6BeReturns the first offset of the pair.BfReturns the second offset of the pair.Ac<code>(A, B)</code>DhInserts an element at position <code>index</code> within the vector, \xe2\x80\xa6CkInsert <code>element</code> at position <code>index</code>.D`The bitwise or (<code>|</code>) of the bits in two flags values.0CkInsert a shape into the set, so that the set will match \xe2\x80\xa6BfInserts a key-value pair into the map.AhAdds a value to the set.DgSets the value of the entry, and returns an <code>OccupiedEntry</code>.CnSets the value of the entry, and returns the entry\xe2\x80\x99s old \xe2\x80\xa6DjSets the value of the entry with the <code>VacantEntry</code>\xe2\x80\x99s key, \xe2\x80\xa62DhSets the value of the entry with the <code>VacantEntryRef</code>\xe2\x80\x99s \xe2\x80\xa63DhSets the value of the entry with the <code>VacantEntry</code>\xe2\x80\x99s value.CmSets the value of the entry, replacing any existing value \xe2\x80\xa6CkInserts a new element into the table with the hash that \xe2\x80\xa6C`Insert a type into this <code>Extensions</code>.9B`Insert the value into the entry.AlSets the value of the entry.DkSets the value of the entry to <code>value</code>, and returns the entry\xe2\x80\xa6CjInserts the entry\xe2\x80\x99s key and the given value into the \xe2\x80\xa61BcInsert a key-value pair in the map.;CmInserts the given key and value into the map, and returns \xe2\x80\xa6AnInsert the value into the set.=<EgInsert <code>value</code> with <code>key</code>, returning the existing value if it \xe2\x80\xa6D`The bitwise or (<code>|</code>) of the bits in two flags values.00000000000CiInsert the given pattern identifier into this set and \xe2\x80\xa6ClReturn a new set that is equivalent to the original, but \xe2\x80\xa60BfInserts a key-value pair into the map.CmSets the value of the entry with the VacantEntry\xe2\x80\x99s key, \xe2\x80\xa6DgSets the value of the entry with the <code>OccupiedEntry</code>\xe2\x80\x99s \xe2\x80\xa6CmInsert a value in the slab, returning key assigned to the \xe2\x80\xa6CnInsert a value in the entry, returning a mutable reference \xe2\x80\xa6DkInsert an element at position <code>index</code>, shifting all elements \xe2\x80\xa6CbInserts an element at position <code>index</code>.AjInverts <code>self</code>.CmReturns true if <code>Interest</code> contains AIO readiness.CaReturns true if the event contains AIO readiness.CcWhether all known bits in this flags value are set.0000000000000CjReturns true if this configuration indicates that some \xe2\x80\xa6EcReturns true when <code>Look::End</code> is satisfied <code>at</code> the given \xe2\x80\xa6ChReturns true if this error was caused by prematurely \xe2\x80\xa6ClReturns true when this unit represents an \xe2\x80\x9cend of input\xe2\x80\xa6DbReturns true if the <code>Value</code> is a number that can be \xe2\x80\xa6DbReturns true if the <code>Number</code> can be represented by f64.EfReturns true if the <code>Value</code> is an integer between <code>i64::MIN</code> \xe2\x80\xa6EgReturns true if the <code>Number</code> is an integer between <code>i64::MIN</code> \xe2\x80\xa6CmReturns true if <code>Interest</code> contains LIO readiness.CaReturns true if the event contains LIO readiness.E`Returns <code>true</code> if this value is <code>NaN</code> and false otherwise.BoReturns <code>true</code> if the number is NaN.DkReturns <code>true</code> if the number is not divisible by <code>2</code>.0BoReturns <code>true</code> if the number is odd.CfReturns <code>true</code> is <code>self</code> is odd.EaReturns <code>true</code> if <code>self</code> is equal to the multiplicative \xe2\x80\xa6DiReturns true if the <code>Value</code> is an integer between zero and \xe2\x80\xa6DjReturns true if the <code>Number</code> is an integer between zero and \xe2\x80\xa6CiChecks that this certificate issued <code>subject</code>.BbSets the <code>issuer</code> flag.BcRaw DER-encoded certificate issuer.BiReturn the DER encoded issuer of the CRL.DkReturns the length of the IV used with this cipher, or <code>None</code>\xe2\x80\xa6BgGet the key for an element in the slab.BgGenerates a new public/private keypair.CkA macro allowing for compile-time construction of valid \xe2\x80\xa6AlReturns the original layout.CaThe layout of the allocation request that failed.BkThe layout that was passed to the allocatorDmLegacy implementations of <code>connect</code> module and <code>Client</code>CnConstruct an \xe2\x80\x9cinvalid length\xe2\x80\x9d error for the given type \xe2\x80\xa6CbThe natural logarithm of the Gamma function (f64).DbGet the value of the <code>SO_LINGER</code> option on this socket.ClReads the linger duration for this socket by getting the \xe2\x80\xa60ChMark a socket as ready to accept incoming connection \xe2\x80\xa6CdConverts the socket into a <code>TcpListener</code>.CeConverts the socket into a <code>UnixListener</code>.BmGets a key/value pair at the specified index.BlReturns the number of elements in the store.=oThe CLDR localeCgThe resolved locale of the returned data, if locale \xe2\x80\xa6BnThe base 10 logarithm of <code>x</code> (f32).C`The natural logarithm of 1+<code>x</code> (f32).BbReturns a reference to the logger.EmPlaces <code>a &lt;&lt; n</code> in <code>self</code>.  Equivalent to <code>a * 2 ^ n</code>.AgMAC message digest typeChMaps this future\xe2\x80\x99s success value to a different value.0CkWraps the current stream in a new stream which maps the \xe2\x80\xa60BkAdditional <code>DataMarker</code> helpers.BmThe data marker of the request, if available.CnComputes the maximum of all the items in the iterator with \xe2\x80\xa6AkThe message digest context.ChThis library provides heavily optimized routines for \xe2\x80\xa6CeSearch for the first occurrence of a byte in a slice.DkProvides architecture independent implementations of <code>memchr</code>\xe2\x80\xa6CiThis module defines 128-bit vector implementations of \xe2\x80\xa6CiThis module defines 256-bit vector implementations of \xe2\x80\xa6CaUtilities to safely compare cryptographic values.CmThis module provides forward and reverse substring search \xe2\x80\xa6CbReturns a reference to the associated HTTP method.BeSet the HTTP method for this request.AfThe request\xe2\x80\x99s methodAgThe HTTP request methodBmThe request method, such as <code>GET</code>.AnReturns the access method OID.CnComputes the minimum of all the items in the iterator with \xe2\x80\xa6ClReturns the modular multiplicative inverse if it exists, \xe2\x80\xa60CbReturns <code>(self ^ exponent) mod modulus</code>CaReturns <code>(self ^ exponent) % modulus</code>.CfSets the <code>msEFS</code> flag to <code>true</code>.CfSets the <code>msSGC</code> flag to <code>true</code>.CaReturns the needle that this finder searches for.0BeNegate this character class in place.AlNegate this character class.AgNegate this byte class.CjCreates a new pkey context for the specified algorithm ID.DbCreates an empty <code>HashTable</code> using the given allocator.BiCreates a new socket configured for IPv4.BiCreates a new socket configured for IPv6.ClTraverses the trie from the current state for this input \xe2\x80\xa60CfSets the <code>nsSGC</code> flag to <code>true</code>.CgOPENSSL_VERSION_NUMBER is a numeric release version \xe2\x80\xa6EgReturns the <code>Asn1Object</code> value of an <code>X509NameEntry</code>. This is \xe2\x80\xa6BhReturns the ASN.1 OID of this algorithm.EhReturns a new span with <code>offset</code> added to this span\xe2\x80\x99s <code>start</code>\xe2\x80\xa6EhReturns a new match with <code>offset</code> added to its span\xe2\x80\x99s <code>start</code>\xe2\x80\xa61AjThe position of the match.BoThe offset at which the quit byte was observed.ClThe offset at which the search stopped. This corresponds \xe2\x80\xa6DiThe absolute offset of this position, starting at <code>0</code> from \xe2\x80\xa6CkReturns the byte position of the next character, or the \xe2\x80\xa6DnCreates a new opaque <code>Ping</code> to be sent via a <code>PingPong</code>.BcParallel iterator types for optionsBgThe currently decompressed data if any.n<code>C</code>CnExecutes the command as a child process, waiting for it to \xe2\x80\xa6CnProvides packed multiple substring search, principally for \xe2\x80\xa6BhReturns an iterator over the parameters.CmReturns the new event\xe2\x80\x99s explicitly-specified parent, if \xe2\x80\xa6ClReturns the new span\xe2\x80\x99s explicitly-specified parent, if \xe2\x80\xa610CaExtracts the contents of the <code>Pkcs12</code>.CkParse a proc-macro2 token stream into the chosen syntax \xe2\x80\xa60AhParsing flags from text.DjMake a parser that is usable with <code>parse_macro_input!</code> in a \xe2\x80\xa6BcPBKDF2 derivation and verification.BcReturns the period of the interval.CkAn NFA backed Pike VM for executing regex searches with \xe2\x80\xa6AbPKCS #12 archives.DiSample data for <code>CodePointTrie</code> that returns the code point\xe2\x80\xa6AnPlanes constituting the frame.AfPoison this connectionDiRemove the element at <code>index</code> and shift down the following \xe2\x80\xa6CmRemoves and returns the last key-value pair from a map if \xe2\x80\xa6ChRemoves and returns the last value from a set if the \xe2\x80\xa6BcReturns the span of a prefix of \xe2\x80\xa6BkCreates a new JSON pretty print serializer.EfReturns <code>true</code> if the two <code>Shared</code>s point to the same future \xe2\x80\xa6BfReturns a reference to the public key.CcWrites a signed 8 bit integer to <code>self</code>.0CfWrites an unsigned 8 bit integer to <code>self</code>.0CiGenerate a random value using the thread-local random \xe2\x80\xa6DhReturn a random value via the <code>StandardUniform</code> distribution.0BhReturn the underlying ranges as a slice.0EhCreates an adaptor which implements the <code>Read</code> trait for <code>self</code>\xe2\x80\xa600BhReturns a reference to the inner reader.BmReturns a reference to the underlying reader.CiIf the error was caused by the remote peer, the error \xe2\x80\xa6CdThe response reason-phrase, such as <code>OK</code>.BkReason for inability to deserialize values.BaReturns the reason for the error.EbIf <code>status</code> is <code>CERT_STATUS_REVOKED</code>, the reason for the \xe2\x80\xa6CfVisits this value with the given <code>Visitor</code>.BaRecord a set of values on a span.0DgVisits all the fields on this <code>Event</code> with the specified \xe2\x80\xa62DiVisits all the fields in this <code>ValueSet</code> with the provided \xe2\x80\xa62DhRecords that the field described by <code>field</code> has the value \xe2\x80\xa6DjRecords all the fields in this set of <code>Attributes</code> with the \xe2\x80\xa6DhRecords all the fields in this <code>Record</code> with the provided \xe2\x80\xa656354105DjReduces the items in the iterator into one item using <code>op</code>. \xe2\x80\xa6CkReduce two final results into one; this is executed after amRegion subtagBiRegion subtag of the language identifier.BcA region field of a Subdivision Id.CkA macro allowing for compile-time construction of valid \xe2\x80\xa6AdPreference of Region4BgPrepares the operation for a new frame.DiRemoves and returns the element at position <code>index</code> within \xe2\x80\xa6DiRemove the element at <code>index</code> and shift down the following \xe2\x80\xa6EeRemoves a <code>char</code> from this <code>ArrayString</code> at a byte position \xe2\x80\xa6CeThe intersection of a source flags value with the \xe2\x80\xa60CnRemoves a key from the map, returning the value at the key \xe2\x80\xa6CkRemoves a value from the set. Returns whether the value wasCkTakes the value out of the entry, and returns it. Keeps \xe2\x80\xa60CjTakes the value out of the entry, and returns it along \xe2\x80\xa6C`Remove a type from this <code>Extensions</code>.CnRemoves a key from the map, returning the value associated \xe2\x80\xa6AnRemove the entry from the map.CiRemove the key, value pair stored in the map for this \xe2\x80\xa6DkRemove the key-value pair equivalent to <code>key</code> and return its \xe2\x80\xa61DiRemove the value from the set, and return <code>true</code> if it was \xe2\x80\xa6CaTakes the value out of the entry, and returns it.D`Remove the value at <code>key</code>, returning it if it exists.DhRemoves <code>other</code> <code>Interest</code> from <code>self</code>.============ClReturn a new set that is equivalent to the original, but \xe2\x80\xa60=ClTakes the value of the entry out of the map, and returns \xe2\x80\xa6CjRemove and return the value associated with the given key.DjRemove and return the element at position <code>index</code>, shifting \xe2\x80\xa6CdRemove <code>Interest</code> from <code>self</code>.ClRenames a file or directory to a new name, replacing the \xe2\x80\xa6CkCreates an instance of a reader that infinitely repeats \xe2\x80\xa6ChCreate a stream which produces the same item repeatedly.DkCreates a parallel iterator that endlessly repeats <code>element</code> \xe2\x80\xa6CjCreates an instance of an async reader that infinitely \xe2\x80\xa6B`Immediately reseed the generator0F`Resizes the <code>Vec</code> in-place so that <code>len</code> is equal to <code>new_len</code>.DmResizes the buffer so that <code>len</code> is equal to <code>new_len</code>.DcResizes the vector so that its length is equal to <code>len</code>.EeResizes a <code>TinyAsciiStr&lt;N&gt;</code> to a <code>TinyAsciiStr&lt;M&gt;</code>.BcParallel iterator types for resultsCeRetains only the elements specified by the predicate.CiRetains only the elements specified by the predicate. \xe2\x80\xa611CnScan through each key-value pair in the map and keep those \xe2\x80\xa6CkScan through each value in the set and keep those where the33CdRetain only the elements specified by the predicate.4CnCreates a future which will rewind to the beginning of the \xe2\x80\xa60DhRound <code>x</code> to the nearest integer, breaking ties away from \xe2\x80\xa6ElPlaces <code>a &gt;&gt; n</code> in <code>self</code>. Equivalent to <code>a / 2 ^ n</code>.CjReturns a reference to the original reader-writer lock \xe2\x80\xa600DcReturns a reference to the original <code>Arc&lt;RwLock&gt;</code>.00CaSample a new value, using the given distribution.0EfGenerate a random value of <code>T</code>, using <code>rng</code> as the source of \xe2\x80\xa6oSample a value.CeSample from distribution, Lemire\xe2\x80\x99s method, unbiased000000000DeRandomly sample exactly <code>amount</code> distinct indices from \xe2\x80\xa6BiSet the <code>Scheme</code> for this URI.BhGet the scheme of this <code>Uri</code>.AmThe scheme component of a URImScript subtagBiScript subtag of the language identifier.CkA macro allowing for compile-time construction of valid \xe2\x80\xa6CkData and APIs for supporting Script_Extensions property \xe2\x80\xa63CkDerives a key from a password and salt using the scrypt \xe2\x80\xa6CnReturns the start and end offset of the leftmost match. If \xe2\x80\xa6CnExecutes a leftmost forward search and writes the spans of \xe2\x80\xa6BnThe number of secret bits used for the cipher.CfPolls multiple futures and streams simultaneously, \xe2\x80\xa60ClWaits for either one of two differently-typed futures to \xe2\x80\xa6CfThis function will attempt to pull items from both \xe2\x80\xa6CmWaits on multiple concurrent branches, returning when the \xe2\x80\xa6AnRaw certificate serial number.BmServer implementation of the HTTP/2 protocol.kHTTP ServerAaServer utilities.BfSet the expected IPv4 or IPv6 address.BfComputes the SHA224 hash of some data.BfComputes the SHA256 hash of some data.BfComputes the SHA384 hash of some data.BfComputes the SHA512 hash of some data.CnCreate a cloneable handle to this future where all handles \xe2\x80\xa60BnConverts this into a <code>SharedGiver</code>.CiApply best effort heuristics to shrink the NFA at the \xe2\x80\xa6BgAsynchronous signal handling for Tokio.CkCreates a new listener which will receive notifications \xe2\x80\xa6CeGet the signed data of a PKCS#7 structure of type \xe2\x80\xa6CoReturns a number that represents the sign of <code>self</code>.0AoReturns the sign of the number.01CiWhether this error was created in silent mode to not log.CkSilent requests do not log errors. This can be used for \xe2\x80\xa6CaBoth the sine and cosine of <code>x</code> (f64).CmReturns the <em>current</em> memory usage of this dictionary.C`Returns the size currently used by this context.CcWraps the <code>ZSTD_sizeof_DCtx()</code> function.2AmBacks off in a blocking loop.CeReturns the lower-level source of this error, if any.00DkThe lower-level source of this error, in the case of a <code>Utf8</code>\xe2\x80\xa6BkTypes and routines specific to sparse DFAs.CkCreates a splicing iterator that replaces the specified \xe2\x80\xa60DkReturns an iterator of at most <code>limit</code> spans of the haystack \xe2\x80\xa6BjReturns a slice of all states in this NFA.CkDetermines whether the executor is able to spawn new tasks.00BdReturns the <code>StatusCode</code>.BfSet the HTTP status for this response.AgThe response\xe2\x80\x99s statusAaHTTP status codesAnThe return status of the call.CgDecompressor status on failure. See TINFLStatus for \xe2\x80\xa6BcReturns the status of the response.BcThe overall status of the response.CnExecutes the command as a child process, waiting for it to \xe2\x80\xa6CiSets configuration for the child process\xe2\x80\x99s standard \xe2\x80\xa6ClThe handle for reading from the child\xe2\x80\x99s standard error \xe2\x80\xa6ChConstructs a new handle to the standard error of the \xe2\x80\xa62CmThe handle for reading from the child\xe2\x80\x99s standard output \xe2\x80\xa6CiConstructs a new handle to the standard output of the \xe2\x80\xa6AeAsynchronous streams.0BjExtra streaming compression functionality.BlExtra streaming decompression functionality.DhReturns the <code>TokenStream</code> of tokens that are delimited in \xe2\x80\xa6EhDue to the <code>Stream</code> trait\xe2\x80\x99s inclusion in <code>std</code> landing later \xe2\x80\xa6BeCompress and decompress Zstd streams.CnReturns the total stride for every state in this DFA. This \xe2\x80\xa60lData stride.oString literal.CnThis module contains the parallel iterator types for owned \xe2\x80\xa6CiAccepts a replacement string and interpolates capture \xe2\x80\xa6CbThis library implements string similarity metrics.CkA macro allowing for compile-time construction of valid \xe2\x80\xa60isubtle   BoA subdivision suffix field of a Subdivision Id.CcGet an optional +suffix for this <code>Mime</code>.CnConfigure the syntax options when parsing a pattern string \xe2\x80\xa6CgSet the syntax configuration for this builder using \xe2\x80\xa60000000CfUtilities for dealing with the syntax of a regular \xe2\x80\xa6BhThe name of the target of the directive.BaSet <code>Metadata::target</code>1AoSetter for <code>target</code>.ClReturns a string describing the part of the system where \xe2\x80\xa60AiThe Gamma function (f64).CaThreads that can borrow variables from the stack.BjReturns a handle to the underlying thread.CkReturns the DER-encoded representation of this certificate.BiSerializes this CmsContentInfo using DER.CcSerializes the DSA signature into a DER-encoded \xe2\x80\xa6CeSerializes the ECDSA signature into a DER-encoded \xe2\x80\xa6CeSerializes the response to its standard DER encoding.CdSerializes the request to its standard DER encoding.D`Serializes the <code>Pkcs12</code> to its standard DER encoding.ChSerializes the data into a DER-encoded PKCS#7 structure.CdSerializes the session into a DER-encoded structure.CfSerializes the certificate into a DER-encoded X509 \xe2\x80\xa6CfSerializes the Extension to its standard DER encoding.CkSerializes the certificate into a DER-encoded X509 name \xe2\x80\xa6CgSerializes the certificate request to a DER-encoded \xe2\x80\xa600EhConverts the value of <code>self</code> to an <code>f32</code>. Overflows may map to \xe2\x80\xa6EhConverts the value of <code>self</code> to an <code>f64</code>. Overflows may map to \xe2\x80\xa6EgConverts the value of <code>self</code> to an <code>i16</code>. If the value cannot \xe2\x80\xa6EgConverts the value of <code>self</code> to an <code>i32</code>. If the value cannot \xe2\x80\xa6EgConverts the value of <code>self</code> to an <code>i64</code>. If the value cannot \xe2\x80\xa6CaMethod returning the concrete value for the type.BiSerializes this CmsContentInfo using DER.ChSerializes the data into a PEM-encoded PKCS#7 structure.CfSerializes the certificate into a PEM-encoded X509 \xe2\x80\xa6CgSerializes the certificate request to a PEM-encoded \xe2\x80\xa60EfYields a <code>&amp;str</code> slice if the <code>HeaderValue</code> only contains \xe2\x80\xa6DaReturn the string representation of this <code>ServerName</code>.EeConverts the value of <code>self</code> to a <code>u16</code>. If the value cannot beDiA method for converting back to a <code>u32</code> that can roundtrip \xe2\x80\xa6EeConverts the value of <code>self</code> to a <code>u32</code>. If the value cannot beEeConverts the value of <code>self</code> to a <code>u64</code>. If the value cannot beCjReturns a big-endian byte vector representation of the \xe2\x80\xa6CiSerialize the given data structure as a JSON byte vector.0DfThe bitwise exclusive-or (<code>^</code>) of the bits in two flags \xe2\x80\xa60BhToggle the value and return the old one.111111111111D`Get the value of the <code>IP_TOS</code> option for this socket.DaGets the value of the <code>IP_TOS</code> option for this socket.0AkTrait this impl implements.ClRounds the number toward 0 to the closest integral value \xe2\x80\xa6EfReturns the <code>Id</code> of the currently running task, or <code>None</code> if \xe2\x80\xa6CnExecute an I/O operation ensuring that the socket receives \xe2\x80\xa600000CbTries to read or write from the socket using a \xe2\x80\xa6000CkTries to read or write from the file descriptor using a \xe2\x80\xa6BcPerforms the provided IO operation.0D`Get the value of the <code>IP_TTL</code> option for this socket.CnAn implementation of the Two-Way substring search algorithm\xe2\x80\xa6CmCreate a sink from a function which processes one item at \xe2\x80\xa6DgCreates a <code>Stream</code> from a seed and a closure returning a \xe2\x80\xa6DcCreates a <code>&amp;mut UninitSlice</code> wrapping a slice of \xe2\x80\xa6DfCreate a new <code>ReadBuf</code> with a slice of uninitialized bytes.D`Creates a new <code>ReadBuf</code> from a buffer that may be \xe2\x80\xa6AcUnlocks this mutex.CnUnlocks this mutex. The inner mutex may not be unlocked if \xe2\x80\xa6fSafetyCjAtomically makes the token available if it is not already.CaSingle-threaded version of <code>OnceCell</code>.ClConvenience method to unwrap a Complete value. Panics if \xe2\x80\xa6DhConvert <code>proc_macro2::Span</code> to <code>proc_macro::Span</code>.CmThis returns the underlying value but panics if it is not \xe2\x80\xa6FjUpcast a <code>DataPayload&lt;T&gt;</code> to a <code>DataPayload&lt;S&gt;</code> where <code>T</code> \xe2\x80\xa6CgProcess the given byte slice and update the hash state.BjProcess data, updating the internal state.AbDigest input data.BeUpdate state using the provided data.CcUpdate the CRC with the bytes in <code>data</code>.AkFeeds data into the hasher.B`Feeds some data into the hasher.0000DbFeeds data from <code>input</code> through the cipher, writing \xe2\x80\xa60BmFeeds more data into the <code>Signer</code>.BoFeeds more data into the <code>Verifier</code>.2CfMutates each item of this iterator before yielding it.CjUpdates the digest with all the data in <code>data</code>.EgUpdates the HMAC with all the data in <code>data</code>. <code>update</code> may be \xe2\x80\xa6;CmUpdates the inner <code>T</code> by calling a function on it.CkAn iterator visiting all values in arbitrary order. The \xe2\x80\xa6B`An iterator visiting all values.CdReturn an iterator over the values of the map slice.CkReturn an iterator over the values of the map, in their \xe2\x80\xa6CfProduce an iterator over values, ordered by their keysBlGets an iterator over the values of the map.DhReturns a reference to a <code>ValueSet</code> containing any values \xe2\x80\xa60CnVerify this CmsContentInfo\xe2\x80\x99s signature, This will search \xe2\x80\xa6CnVerifies if the signature is a valid ECDSA signature using \xe2\x80\xa6BfVerifies the validity of the response.ElVerifies the PKCS#7 <code>signedData</code> structure contained by <code>&amp;self</code>\xe2\x80\xa6CdVerifies the signature of data using the public key.DiDetermines if the data fed into the <code>Verifier</code> matches the \xe2\x80\xa6CmCheck if the certificate is signed using the given public \xe2\x80\xa6CnCheck if the certificate request is signed using the given \xe2\x80\xa6CfCheck if the CRL is signed using the given public key.EhCalculates the HMAC of <code>data</code> using the signing key <code>key</code>, and \xe2\x80\xa6DhVerifies that a previously-derived (e.g., using <code>derive</code>) \xe2\x80\xa6EeVerifies that <code>signature</code> is a valid signature of <code>message</code> \xe2\x80\xa6EdVerify the signature <code>signature</code> of message <code>msg</code> with the \xe2\x80\xa6DhParses the public key and verifies <code>signature</code> is a valid \xe2\x80\xa6Bmwebpki: Web PKI X.509 Certificate Validation.CdReturns the weight at the given index, if it exists.DhCreates an adaptor which implements the <code>Write</code> trait for \xe2\x80\xa60BhReturns a reference to the inner writer.BfGives a reference to the inner writer.CmSet whether HTTP/1 connections should try to use vectored \xe2\x80\xa600CeVector algorithms for the <code>x86_64</code> target.AjCalls <code>zeroed</code>.0DfCreates a new <code>BytesMut</code> containing <code>len</code> zeros.BmConstruct a new storage containing all zeros.DkThe same as <code>Zip</code>, but requires that both iterators have the \xe2\x80\xa6hAES-128.hAES-256.ChAdvertises the availability of alternate services to \xe2\x80\xa6CkIndicator that the <code>Abortable</code> task was aborted.0BnNegative numbers use parentheses or equivalentBdAn address assigned to an interface.AmAdler-32 checksum calculator.AoAn adler32 hash generator type.E`A hack to align a smaller type <code>B</code> with a bigger type <code>T</code>.BlFuture for the <code>and_then</code> method.BlStream for the <code>and_then</code> method.CiService returned by the <code>and_then</code> combinator.AgMatches any byte value.CgMatches the UTF-8 encoding of any Unicode scalar value.BcA way of waking up a specific task.0CkTrait implemented to allow a type to be used as a field \xe2\x80\xa6ChGet the \xe2\x80\x9cshape\xe2\x80\x9d of a fields container, such as a \xe2\x80\xa6C`Something that can be seen as an immutable sliceClAssociates an IO object backed by a Unix file descriptor \xe2\x80\xa6Aa<code>{m,}</code>ClProvides methods to compute the average of two integers, \xe2\x80\xa6BfThe alphabet used in BinHex 4.0 files.BkPerforms exponential backoff in spin loops.BhThe backoff type produced by this maker.CdA backoff trait where a single mutable reference \xe2\x80\xa6CgA barrier enables multiple tasks to synchronize the \xe2\x80\xa6AlA big unsigned integer type.C`Ops that are independent of word size and endianDfAn extension trait for <code>http_body::Body</code> adding various \xe2\x80\xa6BiNumbers which have upper and lower boundsAb<code>{m,n}</code>BgA boxed <code>Body</code> trait object.Ad<code>[ ... ]</code>Ao<code>[</code>\xe2\x80\xa6<code>]</code>CgA builder for constructing a packed searcher from a \xe2\x80\xa6BnA builder for configuring an Aho-Corasick DFA.CiA builder for configuring an Aho-Corasick contiguous NFA.CkA builder for configuring an Aho-Corasick noncontiguous \xe2\x80\xa6CkBuilds client connections with custom configuration values.CkBuilds server connections with custom configuration values.AhAn HTTP response builderAgAn HTTP request builderB`A builder for <code>Uri</code>s.BjA builder to configure an HTTP connection.0CfA configuration builder for HTTP/1 server connections.CfA configuration builder for HTTP/2 server connections.CaA builder to configure a new <code>Client</code>.BkA builder to create a <code>Matcher</code>.BbHttp1 or Http2 connection builder.D`A builder for configuring and constructing a <code>Regex</code>.CjA builder for constructing a lazy deterministic finite \xe2\x80\xa6C`A builder for a regex based on a hybrid NFA/DFA.CeA builder for constructing a deterministic finite \xe2\x80\xa6AmA builder for a one-pass DFA.CgA builder for a regex based on deterministic finite \xe2\x80\xa6CbAn abstraction for building Thompson NFAs by hand.BdA builder for a <code>PikeVM</code>.BdA builder for a bounded backtracker.CfBuilds Tokio Runtime with custom configuration values.CnConfigure length delimited <code>LengthDelimitedCodec</code>s.CeA byte string literal: <code>b&quot;foo&quot;</code>.gcharsetgCONNECTBe201 Created [RFC9110, Section 15.3.2]AcCompression stream.DiThis is a <code>Stream</code> of responses resulting from calling the \xe2\x80\xa6BoAn empty state that records a capture location.CcA capturing group, which contains a sub-expression.CnThe high-level intermediate representation for a capturing \xe2\x80\xa6o<code>^=</code>AkCelsius as temperature unitCgA u8 array of little-endian data corresponding to a \xe2\x80\xa6AlTraditional Chinese calendarClParallel iterator over slice in (non-overlapping) chunks \xe2\x80\xa6C`A closure expression: <code>|a, b| a + b</code>.BkFuture for the <code>collect</code> method.CcFuture that resolves into a <code>Collected</code>.DgThis structure mimics the API of <code>std::process::Command</code> \xe2\x80\xa6CjA comment from a regular expression with an associated \xe2\x80\xa6CfAlias for the associated type of <code>Cmp</code>: \xe2\x80\xa6AdA Condition VariableCdConnect to a destination, returning an IO transport.DaProvides the <code>context</code> method for <code>Result</code>.ChA context for multi-step (Init-Update-Finish) digest \xe2\x80\xa6CkA context for multi-step (Init-Update-Finish) HMAC signing.Bi(<code>Cc</code>) A C0 or C1 control code0C`Future for the <code>copy_buf()</code> function.BfRepresents a symmetric cipher context.DjIndicates what the <code>Subscriber</code> considers the \xe2\x80\x9ccurrent\xe2\x80\x9d \xe2\x80\xa6AgA Decompression stream.hDTLSv1.2CiRegular baked data: a trie for lookups and a slice of \xe2\x80\xa6CkThe tracing is being used to generate a new struct or enum.AoDecoding of frames via buffers.BiAn in-memory decoder for streams of data.DdA decoder that decompress input data from another <code>Read</code>.CiA decoder that decompress and forward data to another \xe2\x80\xa6CjDefault quality of compression defined by the selected \xe2\x80\xa6ChUse the default presentation for emoji characters as \xe2\x80\xa6CaThe character is its own canonical decomposition.BjDon\xe2\x80\x99t use any of the special strategies.AmReturn type is not specified.Ad<code>default</code>CgA type used to derive a shared secret between two keys.EgCustom <code>#[derive(...)]</code> macro for implementing <code>fmt::Display</code> \xe2\x80\xa6CmThe server is identified by a DNS name.  The name is sent \xe2\x80\xa6CjA type which encapsulates a string (borrowed or owned) \xe2\x80\xa6BcVerification of Ed25519 signatures.BmAlgorithmIdentifier for <code>ED25519</code>.BhED25519 signatures according to RFC 8410CfContains the date/time after which the response is \xe2\x80\xa6AcDescribes the curveAoRepresents a point on the curveBhErrors returned by <code>Timeout</code>.AdThe timeout elapsed.BbThe element type of the slice viewCkTrait of helper objects to write out messages as bytes, \xe2\x80\xa6BiAn in-memory encoder for streams of data.DcAn encoder that compress input data from another <code>Read</code>.ChAn encoder that compress and forward data to another \xe2\x80\xa6CmMatch the end of a line or the end of text. Specifically, \xe2\x80\xa60n<code>$</code>o<code>\\z</code>CkEnforce the verification time is before the time in the \xe2\x80\xa6CmA guard representing a span which has been entered and is \xe2\x80\xa6BlFuture for the <code>err_into</code> method.BlStream for the <code>err_into</code> method.ChEthiopic calendar, Amete Alem (epoch approx. 5493 B.C.E)A`<code>{m}</code>CiA <code>let</code> guard: <code>let Some(x) = opt</code>.EbA literal in place of an expression: <code>1</code>, <code>&quot;foo&quot;</code>.BeA try-expression: <code>expr?</code>.nA fatal error.AeThe handshake failed.CkFastest quality of compression, usually produces bigger \xe2\x80\xa6BlFuture for the <code>fill_buf</code> method.BlStream for the <code>flat_map</code> method.Dg<code>FlatMap</code> maps each element to a parallel iterator, then \xe2\x80\xa6BkFuture for the <code>flatten</code> method.BkStream for the <code>flatten</code> method.Dh<code>Flatten</code> turns each element to a parallel iterator, then \xe2\x80\xa6DmA <strong>type operator</strong> that gives the sum of all elements of an \xe2\x80\xa6DnA <strong>type operator</strong> that gives the product of all elements of \xe2\x80\xa6CjAlias for the associated type of <code>FoldAdd</code>: \xe2\x80\xa6BlFuture for the <code>for_each</code> method.CaA for loop: <code>for pat in expr { ... }</code>.BkFuture for the <code>forward</code> method.DiA potential output from <code>Cmp</code>, this is the type equivalent \xe2\x80\xa6AbGregorian calendarAe<code>HTTP/0.9</code>Ae<code>HTTP/1.0</code>Ae<code>HTTP/1.1</code>DfMarker type corresponding to the <code>X509_LOOKUP_hash_dir</code> \xe2\x80\xa6CjA hash map implemented with quadratic probing and SIMD \xe2\x80\xa60EdA hash set implemented as a <code>HashMap</code> where the value is <code>()</code>.0D`The underlying kind of an arbitrary <code>Hir</code> expression.Be226 IM Used [RFC3229, Section 10.4.1]BhCharacters that can begin an identifier.CjAn efficient way of discarding data from a syntax element.DiThis is a <code>VarZeroVecFormat</code> that stores u16s in the index \xe2\x80\xa6DiThis is a <code>VarZeroVecFormat</code> that stores u32s in the index \xe2\x80\xa6CcInherit the eventual value from an external source.BkFuture for the <code>inspect</code> method.BkStream for the <code>inspect</code> method.Dd<code>Inspect</code> is an iterator that calls a function with a \xe2\x80\xa6CbInstant type used for <code>try_lock_until</code>.0CiA measurement of a monotonically nondecreasing clock. \xe2\x80\xa6DaAn integer that can be written into an <code>itoa::Buffer</code>.DcThe <strong>marker trait</strong> for compile time signed integers.BgThe validation callback returned false.EkProvides a <code>bitor()</code> method for <code>Ipv4Addr</code> and <code>Ipv6Addr</code>.AhAn IPv4 network address.AhAn IPv6 network address.F`A <strong>type operator</strong> that returns <code>True</code> if <code>Self == Rhs</code>, \xe2\x80\xa6CgISO calendar (Gregorian calendar using the ISO 8601 \xe2\x80\xa6EaA module or module declaration: <code>mod m</code> or <code>mod m { ... }</code>.D`A use declaration: <code>use alloc::collections::HashMap</code>.CgMutable iterator over all futures in the unordered set.CgMutable iterator over all streams in the unordered set.DdA mutable iterator over the entries of a <code>HashMap</code> in \xe2\x80\xa6DfA mutable iterator over the entries of a <code>HashTable</code> in \xe2\x80\xa6Bm<code>HeaderMap</code> mutable entry iteratorD`A mutable iterator over the entries of an <code>IndexMap</code>.BoA mutable iterator over the stack\xe2\x80\x99s contents.DiA parallel iterator over a mutable reference to the <code>Some</code> \xe2\x80\xa6CfParallel iterator over a mutable reference to a resultBoParallel iterator over mutable items in a sliceChParallel iterator over a mutable reference to a hash mapCjParallel iterator over a mutable reference to a B-Tree mapCkParallel iterator over a mutable reference to a linked listCcParallel iterator over a mutable reference to a \xe2\x80\xa6CfA mutable iterator over a serde_json::Map\xe2\x80\x99s entries.DbA mutable iterator over the values stored in the <code>Slab</code>DiAn iterator over mutably borrowed values of type <code>&amp;mut T</code>.BcSize in bytes of a compression job.0BnFuture for the <code>join_all</code> function.CaA collection of tasks spawned on a Tokio runtime.AbThe length of key.CjCSS lev 3 word-break=keep-all, prohibit midword breaks \xe2\x80\xa6BhTypes which can be initialized from key.BbAn RSA key pair, used for signing.CjKey pairs for signing messages (private key and public \xe2\x80\xa6AbKey size in bytes.ChThe length of the OKM (Output Keying Material) for a \xe2\x80\xa6AoReturn <code>log10(2.0)</code>.AmReturn <code>log10(e)</code>.AoReturn <code>log2(10.0)</code>.EhA <code>Layer</code> implemented by a closure. See the docs for <code>layer_fn</code>\xe2\x80\xa60AfA length limited body.CkA boolean literal: <code>true</code> or <code>false</code>.BjA byte literal: <code>b&#39;f&#39;</code>.DaA nul-terminated C-string literal: <code>c&quot;foo&quot;</code>.BnA character literal: <code>&#39;a&#39;</code>.C`A simple \xe2\x80\x9cflat\xe2\x80\x9d map based on a sorted vectorGgA literal character (<code>&#39;a&#39;</code>), string (<code>&quot;hello&quot;</code>), number (<code>2.3</code>), \xe2\x80\xa6FeA literal string (<code>&quot;hello&quot;</code>), byte string (<code>b&quot;hello&quot;</code>), \xe2\x80\xa6CeA single character literal, which includes escape \xe2\x80\xa6AaA single literal.CbA literal string that matches exactly these bytes.AlA single literal expression.ChThe high-level intermediate representation of a literal.CoA single literal extracted from an <code>Hir</code> expression.CdLookSet is a memory-efficient set of look-around \xe2\x80\xa6B`A set of look-around assertions.AmAll data keys in this module.gmessagegmsgpackBdA list of miniz failed status codes.AfA list of flush types.Dj<code>MapInit</code> is an iterator that transforms the elements of an \xe2\x80\xa6C`Future for the <code>map_into</code> combinator.Dj<code>MapWith</code> is an iterator that transforms the elements of an \xe2\x80\xa6CjA proxy matcher, usually built from environment variables.CfParallel iterator over substrings that match a patternCfAlias for the associated type of <code>Max</code>: \xe2\x80\xa6CmAn iterator over all occurrences of two possible bytes in \xe2\x80\xa6ClAn iterator over all occurrences of three possible bytes \xe2\x80\xa6CfAlias for the associated type of <code>Min</code>: \xe2\x80\xa6o<code>-=</code>Ab<code>mut x</code>AiInvalid byte in new line.DeA special case of <code>Tuple</code> with exactly one field, e.g. \xe2\x80\xa6CnThe input unit(s) did not continue a matching string. Once \xe2\x80\xa6ClThe input unit(s) matched a string but there is no value \xe2\x80\xa6DmA <strong>marker trait</strong> to designate that a type is not zero. All \xe2\x80\xa6CjAn empty syntax tree node that consumes no tokens when \xe2\x80\xa6CaAn interface for casting between machine scalars.gOPTIONSCeA thread-safe cell which can be written to only once.0CjAn iterator over all occurrences of a single byte in a \xe2\x80\xa600EeA <code>Future</code> consuming a <code>Service</code> and request, waiting until \xe2\x80\xa6BmControl struct for searching type parameters.B`Error type of <code>OsRng</code>AdI am an IDLE thread.AdI\xe2\x80\x99m a virtual CPU.AoReference to <code>PKey</code>.BbType of encryption padding to use.CkAll pending output is flushed to the output buffer, but \xe2\x80\xa6AaA partial result.CkZlib partial flush. Currently treated as <code>Sync</code>.DkA path like <code>core::mem::replace</code> possibly containing generic \xe2\x80\xa6CnThe dots in a tuple or slice pattern: <code>[0, 1, ..]</code>.CaA type ascription pattern: <code>foo: f64</code>.CaA pattern that matches any value: <code>_</code>.o<code>::</code>CmRun an anchored search for a specific pattern. This means \xe2\x80\xa6CfFuture for the <code>Peekable::peek_mut</code> method.BoFuture for the <code>pending()</code> function.BoStream for the <code>pending()</code> function.AmIn queue for FIPS validation.n<code>%</code>A`Persian calendarBlPhonebook style ordering (such as in German)CnA context object which can perform asymmetric cryptography \xe2\x80\xa6DfA trait for either <code>Owned</code> or <code>Shared</code> pointers.CgPrecise quality based on the underlying compression \xe2\x80\xa6BeGeneric trait for primitive integers.ChA printer for a regular expression abstract syntax tree.CeA printer for a regular expression\xe2\x80\x99s high-level \xe2\x80\xa6C`Private Extension Type marked as <code>x</code>.CoA list of <code>Private Use Extensions</code> as defined in \xe2\x80\xa6ChA tag type indicating that a key has private components.BlThe goal of tracing generic parameter usage.CnParallel iterator over immutable non-overlapping chunks of \xe2\x80\xa6CnContains the address of the previous web page from which a \xe2\x80\xa6CjInforms the web browser that the current page or frame \xe2\x80\xa6CdCharacters used in the definition of Ideographic \xe2\x80\xa6EkAddress-of operation: <code>&amp;raw const place</code> or <code>&amp;raw mut place</code>.ChA wrapper around a byte buffer that is incrementally \xe2\x80\xa60BaReads the entries in a directory.ClThe type of reducer that is produced if this consumer is \xe2\x80\xa6DhThe reducer is the final step of a <code>Consumer</code> \xe2\x80\x93 after a \xe2\x80\xa6CjIterator adaptor for the <code>repeat_n()</code> function.AkRepresents an HTTP request.AaA parsed Request.ChThe <code>Body</code> body of the <code>Response</code>.CmResults type. This is the \xe2\x80\x98block\xe2\x80\x99 an RNG implementing \xe2\x80\xa6BmThe certificate is in the list and is revokedBgImplementation-level interface for RNGs0AbThe Tokio runtime.AgContinue the handshake.BdA non-recoverable IO error occurred.DnThe <code>UniformSampler</code> implementation supporting type <code>X</code>.BlFuture for the <code>send_all</code> method.E`An asynchronous function from a <code>Request</code> to a <code>Response</code>.CfThe <code>Service</code> value created by this factoryAcThe wrapped service10202CdA thread-safe cell that can be written to only once.DdDefines a <code>GenericSequence</code> which can be shortened by \xe2\x80\xa6Dm<code>GenericSequence</code> that has one less element than <code>Self</code>CfAlias for the associated type of <code>Shr</code>: \xe2\x80\xa6DhAn extension trait for <code>Sink</code>s that provides a variety of \xe2\x80\xa6Ed<code>SkipAny</code> is an iterator that skips over <code>n</code> elements from \xe2\x80\xa6o<code>/=</code>DfA reference to a <code>Socket</code> that can be used to configure \xe2\x80\xa6AhTunnel Proxy via SOCKSv4AhTunnel Proxy via SOCKSv5BaAn escaped solidus <code>/</code>EfWhether a <code>Punct</code> is followed immediately by another <code>Punct</code> \xe2\x80\xa6DkA trait that can provide the <code>Span</code> of the complete contents \xe2\x80\xa6ClThe literal is written as a specially recognized escape, \xe2\x80\xa6BbImplements [<code>SplitAt</code>].AoTypes that can be split in two.CoOptions controlling the behavior of an <code>SslContext</code>.CkMatch the beginning of a line or the beginning of text. \xe2\x80\xa60BkThe identifier of a finite automaton state.CnThe identifier of a finite automaton state, represented by \xe2\x80\xa6BcA stealer handle of a worker queue.CaA mock generator yielding very predictable outputCaJSON input source that reads from a UTF-8 string.BjAt least one task was successfully stolen.BmThe length in bytes of an authentication tag.CmAllows the sender to include additional fields at the end \xe2\x80\xa6Eg<code>TakeAny</code> is an iterator that iterates over <code>n</code> elements from \xe2\x80\xa6CiThe data could not be sent on the channel because the \xe2\x80\xa6DdFuture returned by <code>timeout</code> and <code>timeout_at</code>.AnApplies a timeout to requests.CnA wrapper that implements Tokio\xe2\x80\x99s IO traits for an inner \xe2\x80\xa6BlFuture for the <code>try_fold</code> method.Dg<code>TryFold</code> is an iterator that applies a function over an \xe2\x80\xa6BnFuture for the <code>try_join</code> function.CaA light-weight lock guarded by an atomic boolean.BlFuture for the <code>try_next</code> method.CmAn iterator over all occurrences of two possible bytes in \xe2\x80\xa600DaA raw pointer type: <code>*const T</code> or <code>*mut T</code>.BoProtocol corresponding to <code>UDPLITE</code>.BjThe unknown language identifier \xe2\x80\x9cund\xe2\x80\x9d.AmThe unknown locale \xe2\x80\x9cund\xe2\x80\x9d.AoThe unknown language \xe2\x80\x9cund\xe2\x80\x9d.CeUsed as part of the exchange to upgrade the protocol.BeA type with no alignment requirement.C`Unicode Extension Type marked as <code>u</code>.CeUnicode Extensions provide information about user \xe2\x80\xa6DlA Unicode character class, e.g., <code>\\pL</code> or <code>\\p{Greek}</code>.n<code>u</code>CiA set of characters represented by Unicode scalar values.BkSample values uniformly between two bounds.0CmUnnamed fields of a tuple struct or tuple variant such as \xe2\x80\xa6BjAn unnamed field like <code>self.0</code>.Ad<code>unsized</code>CiA glob import in a <code>use</code> item: <code>*</code>.DhAn identifier imported by a <code>use</code> item: <code>HashMap</code>.DlA path prefix of imports in a <code>use</code> item: <code>core::...</code>.EgA suffix of an import tree in a <code>use</code> item: <code>Type as Renamed</code> \xe2\x80\xa6GoA variant subtag (examples: <code>&quot;macos&quot;</code>, <code>&quot;posix&quot;</code>, <code>&quot;1996&quot;</code> etc.)DiThe <code>Visitor</code> that will be used to deserialize the content \xe2\x80\xa60A`An enum variant.CkVec4 functions which may not be implemented yet for all \xe2\x80\xa6BfRepresents a version of the HTTP spec.AmInvalid byte in HTTP version.fUnusedAd<code>virtual</code>CiA trait for visiting an abstract syntax tree (AST) in \xe2\x80\xa6CiA trait for visiting the high-level IR (HIR) in depth \xe2\x80\xa6ChThis trait represents a visitor that walks through a \xe2\x80\xa60CkGeneral HTTP header contains information about possible \xe2\x80\xa6CmParallel iterator over immutable overlapping windows of a \xe2\x80\xa6CaAn <code>X509</code> certificate revocation list.AoReference to <code>X509</code>.BiAn <code>X509</code> certificate request.CgA zero-copy, byte-aligned vector for fixed-width types.BnTrait for securely erasing values from memory.BgThe positive difference of two numbers.000CdAccept a new incoming connection from this listener.BeAcquires a permit from the semaphore.CjSpecifies a directory from which certificates and CRLs \xe2\x80\xa6CgGet the adler32 checksum of the currently encoded data.CnReturns the adler32 checksum of the currently decompressed \xe2\x80\xa6CgCompute Adler-32 hash on <code>Adler32Hash</code> type.BjCompute Adler-32 hash on reader until EOF.BnCompute Adler-32 hash on buf reader until EOF.BfAdvance the internal cursor of the BufBnAdvance written index within initialized part.CoAdvance the <code>filled</code> cursor by <code>n</code> bytes.2CiReturn the next match for an infallible search if one \xe2\x80\xa6BgReturns the next nonce in the sequence.CeAdvances the size of the filled region of the buffer.BiPerforms AES IGE encryption or decryptionDhIf the <code>Value</code> is a Boolean, returns the associated bool. \xe2\x80\xa6DeReturns the value of this punctuation character as <code>char</code>.CkReturns a convenient single codepoint representation of \xe2\x80\xa60DeIf the <code>Number</code> is an integer, represent it as i128 if \xe2\x80\xa6DhIf the <code>Value</code> is a Null, returns (). Returns None otherwise.ClReturn the underlying representation of this look-around \xe2\x80\xa60BfNumber of seconds since the Unix epochDeIf the <code>Number</code> is an integer, represent it as u128 if \xe2\x80\xa6EhReturns this address as Unix <code>SocketAddr</code> if it is an <code>AF_UNIX</code>\xe2\x80\xa6BlConverts the ASN.1 underlying format to UTF8Bo<code>write_to</code> will use at most n bytes.CmAdds a location to the error, such as a field or variant. \xe2\x80\xa6CjCreate a vector that is aligned to a runtime alignment \xe2\x80\xa6CmThis module contains generic backoff utilities to be used \xe2\x80\xa6CkThis is set to true on average once every 0.5ms for any \xe2\x80\xa6Do<code>write_to</code> will use between <code>n</code> and <code>m</code> bytes.CjThe name which this <code>BindingInfo</code> will bind to.")